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

pyedb/dotnet/database/dotnet/primitive.py

@@ -56,7 +56,7 @@ class PrimitiveDotNet:
     def __init__(self, api, prim_object=None):
         self._app = api
         self.api = api._edb.Cell.Primitive
-        self.edb_api = api._edb
+        self.core = api._edb
         self.prim_obj = prim_object
         self._edb_object = prim_object
 
@@ -133,7 +133,7 @@ class PrimitiveDotNet:
             if _poly is None or _poly.IsNull() or _poly is False:
                 self._logger.error("Failed to create void polygon data")
                 return False
-            point_list = self._app.edb_api.cell.primitive.polygon.create(
+            point_list = self._app.core.cell.primitive.polygon.create(
                 self._app.active_layout, self.layer_name, self.prim_obj.GetNet(), _poly
             ).prim_obj
         elif "prim_obj" in dir(point_list):
@@ -340,7 +340,7 @@ class PrimitiveDotNet:
         maximum_corner_extension : float, optional
             The maximum corner extension (when round corners are not used) at which point the corner is clipped.
         """
-        new_poly = self.polygon_data.edb_api.Expand(offset, tolerance, round_corners, maximum_corner_extension)
+        new_poly = self.polygon_data.core.Expand(offset, tolerance, round_corners, maximum_corner_extension)
         self.polygon_data = new_poly[0]
         return True
 
@@ -361,9 +361,9 @@ class PrimitiveDotNet:
         """
         if not isinstance(factor, str):
             factor = float(factor)
-            polygon_data = self.polygon_data.create_from_arcs(self.polygon_data.edb_api.GetArcData(), True)
+            polygon_data = self.polygon_data.create_from_arcs(self.polygon_data.core.GetArcData(), True)
             if not center:
-                center = self.polygon_data.edb_api.GetBoundingCircleCenter()
+                center = self.polygon_data.core.GetBoundingCircleCenter()
                 if center:
                     polygon_data.Scale(factor, center)
                     self.polygon_data = polygon_data
@@ -422,15 +422,15 @@ class RectangleDotNet(PrimitiveDotNet):
             net = net.api_object
         if isinstance(rep_type, int):
             if rep_type == 1:
-                rep_type = self.edb_api.cell.primitive.RectangleRepresentationType.CenterWidthHeight
+                rep_type = self.core.cell.primitive.RectangleRepresentationType.CenterWidthHeight
             else:
-                rep_type = self.edb_api.cell.primitive.RectangleRepresentationType.LowerLeftUpperRight
-        param1 = self._app.edb_api.utility.value(param1)
-        param2 = self._app.edb_api.utility.value(param2)
-        param3 = self._app.edb_api.utility.value(param3)
-        param4 = self._app.edb_api.utility.value(param4)
-        corner_rad = self._app.edb_api.utility.value(corner_rad)
-        rotation = self._app.edb_api.utility.value(rotation)
+                rep_type = self.core.cell.primitive.RectangleRepresentationType.LowerLeftUpperRight
+        param1 = self._app.core.utility.value(param1)
+        param2 = self._app.core.utility.value(param2)
+        param3 = self._app.core.utility.value(param3)
+        param4 = self._app.core.utility.value(param4)
+        corner_rad = self._app.core.utility.value(corner_rad)
+        rotation = self._app.core.utility.value(rotation)
         return RectangleDotNet(
             self._app,
             self.api.Rectangle.Create(
@@ -742,10 +742,10 @@ class PathDotNet(PrimitiveDotNet):
         """
         if isinstance(net, NetDotNet):
             net = net.api_object
-        width = self._app.edb_api.utility.value(width)
+        width = self._app.core.utility.value(width)
         if isinstance(points, list):
             points = convert_py_list_to_net_list([self._app.point_data(i[0], i[1]) for i in points])
-            points = self._app.edb_api.geometry.polygon_data.dotnetobj(points)
+            points = self._app.core.geometry.polygon_data.dotnetobj(points)
         return PathDotNet(
             self._app, self.api.Path.Create(layout, layer, net, width, end_cap1, end_cap2, corner_style, points)
         )
@@ -1501,7 +1501,7 @@ class BoardBendDef(PrimitiveDotNet):
 
         Read-Only.
         """
-        return cast(self.edb_api, self.prim_obj.GetBoundaryPrim())
+        return cast(self.core, self.prim_obj.GetBoundaryPrim())
 
     @property
     def bend_middle(self):

pyedb/dotnet/database/edb_data/hfss_extent_info.py

@@ -38,14 +38,14 @@ class HfssExtentInfo:
         self._pedb = pedb
 
         self._hfss_extent_info_type = {
-            "bounding_box": self._pedb.edb_api.utility.utility.HFSSExtentInfoType.BoundingBox,
-            "conforming": self._pedb.edb_api.utility.utility.HFSSExtentInfoType.Conforming,
-            "convexHull": self._pedb.edb_api.utility.utility.HFSSExtentInfoType.ConvexHull,
-            "polygon": self._pedb.edb_api.utility.utility.HFSSExtentInfoType.Polygon,
+            "bounding_box": self._pedb.core.utility.utility.HFSSExtentInfoType.BoundingBox,
+            "conforming": self._pedb.core.utility.utility.HFSSExtentInfoType.Conforming,
+            "convexHull": self._pedb.core.utility.utility.HFSSExtentInfoType.ConvexHull,
+            "polygon": self._pedb.core.utility.utility.HFSSExtentInfoType.Polygon,
         }
         self._open_region_type = {
-            "radiation": self._pedb.edb_api.utility.utility.OpenRegionType.Radiation,
-            "pml": self._pedb.edb_api.utility.utility.OpenRegionType.PML,
+            "radiation": self._pedb.core.utility.utility.OpenRegionType.Radiation,
+            "pml": self._pedb.core.utility.utility.OpenRegionType.PML,
         }
 
     def _get_edb_value(self, value):

pyedb/dotnet/database/edb_data/layer_data.py

@@ -49,7 +49,7 @@ class LayerEdbClass(object):
         layer_type = self._layer_name_mapping[layer_type]
         layer_type = self._doc_layer_mapping[layer_type]
 
-        self._edb_object = self._pedb.edb_api.cell._cell.Layer(
+        self._edb_object = self._pedb.core.cell._cell.Layer(
             self._name,
             layer_type,
         )
@@ -76,7 +76,9 @@ class LayerEdbClass(object):
 
     @fill_material.setter
     def fill_material(self, value):
-        self._edb_object.SetFillMaterial(value)
+        layer_clone = self._edb_layer
+        layer_clone.SetFillMaterial(value)
+        self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
 
     @property
     def _stackup_layer_mapping(self):
@@ -144,7 +146,7 @@ class LayerEdbClass(object):
 
     @property
     def _edb(self):
-        return self._pedb.edb_api
+        return self._pedb.core
 
     @property
     def _edb_layer(self):
@@ -287,7 +289,7 @@ class StackupLayerEdbClass(LayerEdbClass):
     def _create(self, layer_type):
         layer_type_edb_name = self._layer_name_mapping[layer_type]
         layer_type = self._layer_type_mapping[layer_type_edb_name]
-        self._edb_object = self._pedb.edb_api.cell._cell.StackupLayer(
+        self._edb_object = self._pedb.core.cell._cell.StackupLayer(
             self._name,
             layer_type,
             self._pedb.edb_value(0),
@@ -637,11 +639,11 @@ class StackupLayerEdbClass(LayerEdbClass):
         if not self.is_stackup_layer:  # pragma: no cover
             return
         if surface == "top":
-            return self._edb_layer.GetRoughnessModel(self._pedb.edb_api.Cell.RoughnessModel.Region.Top)
+            return self._edb_layer.GetRoughnessModel(self._pedb.core.Cell.RoughnessModel.Region.Top)
         elif surface == "bottom":
-            return self._edb_layer.GetRoughnessModel(self._pedb.edb_api.Cell.RoughnessModel.Region.Bottom)
+            return self._edb_layer.GetRoughnessModel(self._pedb.core.Cell.RoughnessModel.Region.Bottom)
         elif surface == "side":
-            return self._edb_layer.GetRoughnessModel(self._pedb.edb_api.Cell.RoughnessModel.Region.Side)
+            return self._edb_layer.GetRoughnessModel(self._pedb.core.Cell.RoughnessModel.Region.Side)
 
     def assign_roughness_model(
         self,
@@ -683,27 +685,27 @@ class StackupLayerEdbClass(LayerEdbClass):
         if apply_on_surface == "all":
             self._side_roughness = "all"
             regions = [
-                self._pedb.edb_api.Cell.RoughnessModel.Region.Top,
-                self._pedb.edb_api.Cell.RoughnessModel.Region.Side,
-                self._pedb.edb_api.Cell.RoughnessModel.Region.Bottom,
+                self._pedb.core.Cell.RoughnessModel.Region.Top,
+                self._pedb.core.Cell.RoughnessModel.Region.Side,
+                self._pedb.core.Cell.RoughnessModel.Region.Bottom,
             ]
         elif apply_on_surface == "top":
             self._side_roughness = "top"
-            regions = [self._pedb.edb_api.Cell.RoughnessModel.Region.Top]
+            regions = [self._pedb.core.Cell.RoughnessModel.Region.Top]
         elif apply_on_surface == "bottom":
             self._side_roughness = "bottom"
-            regions = [self._pedb.edb_api.Cell.RoughnessModel.Region.Bottom]
+            regions = [self._pedb.core.Cell.RoughnessModel.Region.Bottom]
         elif apply_on_surface == "side":
             self._side_roughness = "side"
-            regions = [self._pedb.edb_api.Cell.RoughnessModel.Region.Side]
+            regions = [self._pedb.core.Cell.RoughnessModel.Region.Side]
 
         layer_clone = self._edb_layer
         layer_clone.SetRoughnessEnabled(True)
         for r in regions:
             if model_type == "huray":
-                model = self._pedb.edb_api.Cell.HurrayRoughnessModel(radius, surface_ratio)
+                model = self._pedb.core.Cell.HurrayRoughnessModel(radius, surface_ratio)
             else:
-                model = self._pedb.edb_api.Cell.GroisseRoughnessModel(groisse_roughness)
+                model = self._pedb.core.Cell.GroisseRoughnessModel(groisse_roughness)
             layer_clone.SetRoughnessModel(r, model)
         return self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
 

pyedb/dotnet/database/edb_data/padstacks_data.py

@@ -954,13 +954,13 @@ class EDBPadstack(object):
                 stop = layer_names[layer_names.index(layer_name) + 1]
                 new_padstack_name = "MV_{}_{}_{}".format(self.name, start, stop)
                 included = [start, stop]
-                new_padstack_definition_data = self._ppadstack._pedb.edb_api.definition.PadstackDefData.Create()
+                new_padstack_definition_data = self._ppadstack._pedb.core.definition.PadstackDefData.Create()
                 new_padstack_definition_data.AddLayers(convert_py_list_to_net_list(included))
                 for layer in included:
                     pl = self.pad_by_layer[layer]
                     new_padstack_definition_data.SetPadParameters(
                         layer,
-                        self._ppadstack._pedb.edb_api.definition.PadType.RegularPad,
+                        self._ppadstack._pedb.core.definition.PadType.RegularPad,
                         pl.int_to_geometry_type(pl.geometry_type),
                         list(
                             pl._edb_padstack.GetData().GetPadParametersValue(
@@ -980,7 +980,7 @@ class EDBPadstack(object):
                     pl = self.antipad_by_layer[layer]
                     new_padstack_definition_data.SetPadParameters(
                         layer,
-                        self._ppadstack._pedb.edb_api.definition.PadType.AntiPad,
+                        self._ppadstack._pedb.core.definition.PadType.AntiPad,
                         pl.int_to_geometry_type(pl.geometry_type),
                         list(
                             pl._edb_padstack.GetData().GetPadParametersValue(
@@ -1000,7 +1000,7 @@ class EDBPadstack(object):
                     pl = self.thermalpad_by_layer[layer]
                     new_padstack_definition_data.SetPadParameters(
                         layer,
-                        self._ppadstack._pedb.edb_api.definition.PadType.ThermalPad,
+                        self._ppadstack._pedb.core.definition.PadType.ThermalPad,
                         pl.int_to_geometry_type(pl.geometry_type),
                         list(
                             pl._edb_padstack.GetData().GetPadParametersValue(
@@ -1422,7 +1422,7 @@ class EDBPadstackInstance(Primitive):
         tuple
             Tuple of the layer name, drill diameter, and offset if it exists.
         """
-        layer = self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer)
+        layer = self._pedb.core.cell.layer("", self._pedb.core.cell.layer_type.SignalLayer)
         val = self._pedb.edb_value(0)
         offset = self._pedb.edb_value(0.0)
         (
@@ -1488,7 +1488,7 @@ class EDBPadstackInstance(Primitive):
         tuple
             Tuple of the layer name, drill diameter, and drill offset if it exists.
         """
-        layer = self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer)
+        layer = self._pedb.core.cell.layer("", self._pedb.core.cell.layer_type.SignalLayer)
         val = self._pedb.edb_value(0)
         offset = self._pedb.edb_value(0.0)
         (
@@ -1509,7 +1509,7 @@ class EDBPadstackInstance(Primitive):
     def backdrill_parameters(self):
         data = {}
         flag, drill_to_layer, offset, diameter = self._edb_object.GetBackDrillParametersLayerValue(
-            self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer),
+            self._pedb.core.cell.layer("", self._pedb.core.cell.layer_type.SignalLayer),
             self._pedb.edb_value(0),
             self._pedb.edb_value(0.0),
             True,
@@ -1522,7 +1522,7 @@ class EDBPadstackInstance(Primitive):
                     "stub_length": offset.ToString(),
                 }
         flag, drill_to_layer, offset, diameter = self._edb_object.GetBackDrillParametersLayerValue(
-            self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer),
+            self._pedb.core.cell.layer("", self._pedb.core.cell.layer_type.SignalLayer),
             self._pedb.edb_value(0),
             self._pedb.edb_value(0.0),
             False,
@@ -1710,7 +1710,7 @@ class EDBPadstackInstance(Primitive):
                 pos.append(self._pedb.edb_value(v))
             else:
                 pos.append(v)
-        point_data = self._pedb.edb_api.geometry.point_data(pos[0], pos[1])
+        point_data = self._pedb.core.geometry.point_data(pos[0], pos[1])
         self._edb_padstackinstance.SetPositionAndRotation(point_data, self._pedb.edb_value(self.rotation))
 
     @property
@@ -1738,7 +1738,7 @@ class EDBPadstackInstance(Primitive):
     @name.setter
     def name(self, value):
         self._edb_padstackinstance.SetName(value)
-        self._edb_padstackinstance.SetProductProperty(self._pedb.edb_api.ProductId.Designer, 11, value)
+        self._edb_padstackinstance.SetProductProperty(self._pedb.core.ProductId.Designer, 11, value)
 
     @property
     def metal_volume(self):
@@ -1806,7 +1806,7 @@ class EDBPadstackInstance(Primitive):
         """
 
         val = String("")
-        _, name = self._edb_padstackinstance.GetProductProperty(self._pedb.edb_api.ProductId.Designer, 11, val)
+        _, name = self._edb_padstackinstance.GetProductProperty(self._pedb.core.ProductId.Designer, 11, val)
         aedt_name = str(name).strip("'")
         if aedt_name == "":
             if self.is_pin and self.component:
@@ -1818,7 +1818,7 @@ class EDBPadstackInstance(Primitive):
 
     @aedt_name.setter
     def aedt_name(self, value):
-        self._edb_object.SetProductProperty(self._pedb.edb_api.ProductId.Designer, 11, value)
+        self._edb_object.SetProductProperty(self._pedb.core.ProductId.Designer, 11, value)
 
     def parametrize_position(self, prefix=None):
         """Parametrize the instance position.

pyedb/dotnet/database/edb_data/primitives_data.py

@@ -109,7 +109,7 @@ class EdbPolygon(Primitive):
             new_polygons = list(self.polygon_data._edb_object.RemoveSelfIntersections())
             self._edb_object.SetPolygonData(new_polygons[0])
             for p in new_polygons[1:]:
-                cloned_poly = self._app.edb_api.cell.primitive.polygon.create(
+                cloned_poly = self._app.core.cell.primitive.polygon.create(
                     self._app.active_layout, self.layer_name, self.net, p
                 )
                 new_polys.append(cloned_poly)
@@ -258,7 +258,7 @@ class EdbPolygon(Primitive):
             ``True`` when successful, ``False`` when failed.
         """
         if isinstance(point_data, list):
-            point_data = self._app.edb_api.geometry.point_data(
+            point_data = self._app.core.geometry.point_data(
                 self._app.edb_value(point_data[0]), self._app.edb_value(point_data[1])
             )
         int_val = int(self.polygon_data._edb_object.PointInPolygon(point_data))
@@ -297,7 +297,7 @@ class EdbPolygon(Primitive):
     #         if _poly is None or _poly.IsNull() or _poly is False:
     #             self._logger.error("Failed to create void polygon data")
     #             return False
-    #         prim = self._app.edb_api.cell.primitive.polygon.create(
+    #         prim = self._app.core.cell.primitive.polygon.create(
     #             self._app.active_layout, self.layer_name, self.primitive_object.GetNet(), _poly
     #         )
     #     elif isinstance(point_list, Primitive):

pyedb/dotnet/database/edb_data/sources.py

@@ -369,28 +369,28 @@ class PinGroup(object):
 
     def create_current_source_terminal(self, magnitude=1, phase=0):
         terminal = self.create_terminal()._edb_object
-        terminal.SetBoundaryType(self._pedb.edb_api.cell.terminal.BoundaryType.kCurrentSource)
+        terminal.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.kCurrentSource)
         terminal.SetSourceAmplitude(self._pedb.edb_value(magnitude))
-        terminal.SetSourcePhase(self._pedb.edb_api.utility.value(phase))
+        terminal.SetSourcePhase(self._pedb.core.utility.value(phase))
         return terminal
 
     def create_voltage_source_terminal(self, magnitude=1, phase=0, impedance=0.001):
         terminal = self.create_terminal()._edb_object
-        terminal.SetBoundaryType(self._pedb.edb_api.cell.terminal.BoundaryType.kVoltageSource)
+        terminal.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.kVoltageSource)
         terminal.SetSourceAmplitude(self._pedb.edb_value(magnitude))
-        terminal.SetSourcePhase(self._pedb.edb_api.utility.value(phase))
+        terminal.SetSourcePhase(self._pedb.core.utility.value(phase))
         terminal.SetImpedance(self._pedb.edb_value(impedance))
         return terminal
 
     def create_voltage_probe_terminal(self, impedance=1000000):
         terminal = self.create_terminal()._edb_object
-        terminal.SetBoundaryType(self._pedb.edb_api.cell.terminal.BoundaryType.kVoltageProbe)
+        terminal.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.kVoltageProbe)
         terminal.SetImpedance(self._pedb.edb_value(impedance))
         return terminal
 
     def create_port_terminal(self, impedance=50):
         terminal = self.create_terminal()._edb_object
-        terminal.SetBoundaryType(self._pedb.edb_api.cell.terminal.BoundaryType.PortBoundary)
+        terminal.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.PortBoundary)
         terminal.SetImpedance(self._pedb.edb_value(impedance))
         terminal.SetIsCircuitPort(True)
         return terminal

pyedb/dotnet/database/edb_data/variables.py

@@ -19,6 +19,7 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
+import warnings
 
 
 class Variable:
@@ -57,7 +58,10 @@ class Variable:
         str
 
         """
-        return self._var_server.GetVariableValue(self.name)[1].ToString()
+        warnings.warn(
+            "`value_string` is deprecated. Use `str(value)` method instead.", DeprecationWarning, stacklevel=2
+        )
+        return str(self.value)
 
     @property
     def value_object(self):
@@ -77,11 +81,11 @@ class Variable:
         -------
         float
         """
-        return self._var_server.GetVariableValue(self.name)[1].ToDouble()
+        return self._pedb.value(self._var_server.GetVariableValue(self.name)[1])
 
     @value.setter
     def value(self, value):
-        self._var_server.SetVariableValue(self.name, self._pedb.edb_value(value))
+        self._var_server.SetVariableValue(self.name, self._pedb.value(value)._edb_obj)
 
     @property
     def description(self):

pyedb/dotnet/database/geometry/point_data.py

@@ -31,7 +31,7 @@ class PointData:
         else:
             x = x if x else 0
             y = y if y else 0
-            self._edb_object = self._pedb.edb_api.geometry.point_data(
+            self._edb_object = self._pedb.core.geometry.point_data(
                 self._pedb.edb_value(x),
                 self._pedb.edb_value(y),
             )

pyedb/dotnet/database/geometry/polygon_data.py

@@ -91,13 +91,11 @@ class PolygonData:
         list_of_point_data = []
         for pt in points:
             list_of_point_data.append(PointData(self._pedb, x=pt[0], y=pt[1])._edb_object)
-        return self._pedb.edb_api.geometry.api_class.PolygonData(
-            convert_py_list_to_net_list(list_of_point_data), closed
-        )
+        return self._pedb.core.geometry.api_class.PolygonData(convert_py_list_to_net_list(list_of_point_data), closed)
 
     def create_from_bounding_box(self, points):
         bbox = BBox(self._pedb, point_1=points[0], point_2=points[1])
-        return self._pedb.edb_api.geometry.api_class.PolygonData.CreateFromBBox(bbox._edb_object)
+        return self._pedb.core.geometry.api_class.PolygonData.CreateFromBBox(bbox._edb_object)
 
     def expand(self, offset=0.001, tolerance=1e-12, round_corners=True, maximum_corner_extension=0.001):
         """Expand the polygon shape by an absolute value in all direction.

pyedb/dotnet/database/hfss.py

@@ -70,7 +70,7 @@ class EdbHfss(object):
         -------
         Ansys.Ansoft.Edb
         """
-        return self._pedb.edb_api
+        return self._pedb.core
 
     @property
     def _active_layout(self):
@@ -884,7 +884,7 @@ class EdbHfss(object):
             ]
         )
         pos_edge_term.SetProductSolverOption(
-            self._pedb.edb_api.ProductId.Designer,
+            self._pedb.core.ProductId.Designer,
             "HFSS",
             prop,
         )
@@ -939,7 +939,7 @@ class EdbHfss(object):
         if not layer_alignment == "Upper":
             layer_alignment = "Lower"
         pos_edge_term.SetProductSolverOption(
-            self._pedb.edb_api.ProductId.Designer,
+            self._pedb.core.ProductId.Designer,
             "HFSS",
             "HFSS('HFSS Type'='Gap(coax)', Orientation='Horizontal', 'Layer Alignment'='{}')".format(layer_alignment),
         )
@@ -1144,7 +1144,7 @@ class EdbHfss(object):
                                         ref_prim = [
                                             prim
                                             for prim in reference_net.primitives
-                                            if prim.polygon_data.edb_api.PointInPolygon(mid_pt_data)
+                                            if prim.polygon_data.core.PointInPolygon(mid_pt_data)
                                         ]
                                         if ref_prim:
                                             self._logger.info("Reference primitive found")
@@ -1401,7 +1401,7 @@ class EdbHfss(object):
         l_inst = layout.GetLayoutInstance()
 
         for inst in simulation_setup.components:  # pragma: no cover
-            comp = self._pedb.edb_api.cell.hierarchy.component.FindByName(layout, inst)
+            comp = self._pedb.core.cell.hierarchy.component.FindByName(layout, inst)
             if comp.IsNull():
                 continue
 
@@ -1473,7 +1473,7 @@ class EdbHfss(object):
             cmp_names = []
         ii = 0
         for cc in cmp_names:
-            cmp = self._pedb.edb_api.cell.hierarchy.component.FindByName(self._active_layout, cc)
+            cmp = self._pedb.core.cell.hierarchy.component.FindByName(self._active_layout, cc)
             if cmp.IsNull():
                 self._logger.warning("RenamePorts: could not find component {0}".format(cc))
                 continue
@@ -1512,7 +1512,7 @@ class EdbHfss(object):
                             "'PEC Launch Width'='0mm')"
                         )
                         for tt in terms:
-                            tt.SetProductSolverOption(self._edb.edb_api.ProductId.Designer, "HFSS", option)
+                            tt.SetProductSolverOption(self._edb.core.ProductId.Designer, "HFSS", option)
         return True
 
     def _get_terminals_bbox(self, comp, l_inst, terminals_only):

pyedb/dotnet/database/materials.py

@@ -111,7 +111,7 @@ class Material(object):
 
     def __init__(self, edb: Edb, material_def):
         self.__edb: Edb = edb
-        self.__edb_definition = edb.edb_api.definition
+        self.__edb_definition = edb.core.definition
         self.__name: str = material_def.GetName()
         self.__material_def = material_def
         self.__dc_model = material_def.GetDielectricMaterialModel()
@@ -553,7 +553,7 @@ class Materials(object):
 
     def __init__(self, edb: Edb):
         self.__edb = edb
-        self.__edb_definition = edb.edb_api.definition
+        self.__edb_definition = edb.core.definition
         self.__syslib = os.path.join(self.__edb.base_path, "syslib")
 
     def __contains__(self, item):

pyedb/dotnet/database/modeler.py

@@ -70,7 +70,7 @@ class Modeler(object):
 
     @property
     def _edb(self):
-        return self._pedb.edb_api
+        return self._pedb.core
 
     def _get_edb_value(self, value):
         return self._pedb.edb_value(value)
@@ -289,20 +289,20 @@ class Modeler(object):
         if not isinstance(point, list) and len(point) == 2:
             self._logger.error("Provided point must be a list of two values")
             return False
-        pt = self._edb.geometry.point_data(point[0], point[1])
-        if isinstance(nets, str):
-            nets = [nets]
-        elif nets and not isinstance(nets, list) and len(nets) == len([net for net in nets if isinstance(net, str)]):
+        pt = self._edb.geometry.point_data(self._pedb.edb_value(point[0]), self._pedb.edb_value(point[1]))
+        if nets:
+            if isinstance(nets, str):
+                nets = [nets]
             _nets = []
             for net in nets:
                 if net not in self._pedb.nets:
-                    self._logger.error(
+                    self._logger.warning(
                         f"Net {net} used to find primitive from layer point and net not found, skipping it."
                     )
                 else:
                     _nets.append(self._pedb.nets[net].net_obj)
             if _nets:
-                nets = _nets
+                nets = convert_py_list_to_net_list(_nets)
         _obj_instances = list(self._pedb.layout_instance.FindLayoutObjInstance(pt, None, nets).Items)
         returned_obj = []
         if layer:
@@ -324,10 +324,7 @@ class Modeler(object):
         else:
             for obj in _obj_instances:
                 obj_id = obj.GetLayoutObj().GetId()
-                [
-                    returned_obj.append(Primitive(p, self._pedb))
-                    for p in [obj for obj in self.primitives if obj.id == obj_id]
-                ]
+                [returned_obj.append(p) for p in [obj for obj in self.primitives if obj.id == obj_id]]
         return returned_obj
 
     def get_polygon_bounding_box(self, polygon):

pyedb/dotnet/database/nets.py

@@ -77,7 +77,7 @@ class EdbNets(CommonNets):
     @property
     def _edb(self):
         """ """
-        return self._pedb.edb_api
+        return self._pedb.core
 
     @property
     def _active_layout(self):

pyedb/dotnet/database/padstack.py

@@ -23,7 +23,9 @@
 """
 This module contains the `EdbPadstacks` class.
 """
+from collections import defaultdict
 import math
+from typing import Dict, List
 import warnings
 
 import numpy as np
@@ -82,7 +84,7 @@ class EdbPadstacks(object):
     @property
     def _edb(self):
         """ """
-        return self._pedb.edb_api
+        return self._pedb.core
 
     def _get_edb_value(self, value):
         return self._pedb.edb_value(value)
@@ -1871,3 +1873,72 @@ class EdbPadstacks(object):
                         all_instances[item].delete()
 
                 return True
+
+    @staticmethod
+    def dbscan(
+        padstack: Dict[int, List[float]], max_distance: float = 1e-3, min_samples: int = 5
+    ) -> Dict[int, List[str]]:
+        """
+        density based spatial clustering for padstack instances
+
+        Parameters
+        ----------
+        padstack : dict.
+            padstack id: [x, y]
+
+        max_distance: float
+            maximum distance between two points to be included in one cluster
+
+        min_samples: int
+            minimum number of points that a cluster must have
+
+        Returns
+        -------
+        dict
+            clusters {cluster label: [padstack ids]} <
+        """
+
+        padstack_ids = list(padstack.keys())
+        xy_array = np.array([padstack[pid] for pid in padstack_ids])
+        n = len(padstack_ids)
+
+        labels = -1 * np.ones(n, dtype=int)
+        visited = np.zeros(n, dtype=bool)
+        cluster_id = 0
+
+        def region_query(point_idx):
+            distances = np.linalg.norm(xy_array - xy_array[point_idx], axis=1)
+            return np.where(distances <= max_distance)[0]
+
+        def expand_cluster(point_idx, neighbors):
+            nonlocal cluster_id
+            labels[point_idx] = cluster_id
+            i = 0
+            while i < len(neighbors):
+                neighbor_idx = neighbors[i]
+                if not visited[neighbor_idx]:
+                    visited[neighbor_idx] = True
+                    neighbor_neighbors = region_query(neighbor_idx)
+                    if len(neighbor_neighbors) >= min_samples:
+                        neighbors = np.concatenate((neighbors, neighbor_neighbors))
+                if labels[neighbor_idx] == -1:
+                    labels[neighbor_idx] = cluster_id
+                i += 1
+
+        for point_idx in range(n):
+            if visited[point_idx]:
+                continue
+            visited[point_idx] = True
+            neighbors = region_query(point_idx)
+            if len(neighbors) < min_samples:
+                labels[point_idx] = -1
+            else:
+                expand_cluster(point_idx, neighbors)
+                cluster_id += 1
+
+        # group point IDs by label
+        clusters = defaultdict(list)
+        for i, label in enumerate(labels):
+            clusters[int(label)].append(padstack_ids[i])
+
+        return dict(clusters)