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

pyedb/dotnet/database/dotnet/database.py

@@ -36,7 +36,6 @@ from pyedb.generic.general_methods import (
     settings,
 )
 from pyedb.generic.grpc_warnings import GRPC_GENERAL_WARNING
-from pyedb.misc.misc import list_installed_ansysem
 
 
 class HierarchyDotNet:
@@ -53,8 +52,8 @@ class HierarchyDotNet:
 
     def __init__(self, app):
         self._app = app
-        self.edb_api = self._app._edb
-        self._hierarchy = self.edb_api.Cell.Hierarchy
+        self.core = self._app._edb
+        self._hierarchy = self.core.Cell.Hierarchy
 
     @property
     def api_class(self):  # pragma: no cover
@@ -91,8 +90,8 @@ class PolygonDataDotNet:  # pragma: no cover
 
     def __init__(self, pedb, api_object=None):
         self._pedb = pedb
-        self.dotnetobj = pedb.edb_api.geometry.api_class.PolygonData
-        self.edb_api = api_object
+        self.dotnetobj = pedb.core.geometry.api_class.PolygonData
+        self.core = api_object
         self._edb_object = api_object
 
     @property
@@ -103,7 +102,7 @@ class PolygonDataDotNet:  # pragma: no cover
     @property
     def arcs(self):  # pragma: no cover
         """List of Edb.Geometry.ArcData."""
-        return list(self.edb_api.GetArcData())
+        return list(self.core.GetArcData())
 
     def add_point(self, x, y, incremental=False):
         """Add a point at the end of the point list of the polygon.
@@ -129,7 +128,7 @@ class PolygonDataDotNet:  # pragma: no cover
             last_point = self.get_points()[-1]
             x = "({})+({})".format(x, last_point[0].ToString())
             y = "({})+({})".format(y, last_point[1].ToString())
-        return self.edb_api.AddPoint(GeometryDotNet(self._pedb).point_data(x, y))
+        return self.core.AddPoint(GeometryDotNet(self._pedb).point_data(x, y))
 
     def get_bbox_of_boxes(self, points):
         """Get the EDB .NET API ``Edb.Geometry.GetBBoxOfBoxes`` database.
@@ -162,9 +161,7 @@ class PolygonDataDotNet:  # pragma: no cover
         from pyedb.dotnet.clr_module import Tuple
 
         if isinstance(points, (tuple, list)):
-            points = Tuple[self._pedb.edb_api.Geometry.PointData, self._pedb.edb_api.Geometry.PointData](
-                points[0], points[1]
-            )
+            points = Tuple[self._pedb.core.Geometry.PointData, self._pedb.core.Geometry.PointData](points[0], points[1])
         return self.dotnetobj.CreateFromBBox(points)
 
     def create_from_arcs(self, arcs, flag):
@@ -212,7 +209,7 @@ class NetDotNet:
     def __init__(self, app, net_obj=None):
         self.net = app._edb.Cell.Net
 
-        self.edb_api = app._edb
+        self.core = app._edb
         self._app = app
         self.net_obj = net_obj
 
@@ -283,7 +280,7 @@ class NetClassDotNet:
     def __init__(self, app, api_object=None):
         self.cell_net_class = app._edb.Cell.NetClass
         self.api_object = api_object
-        self.edb_api = app._edb
+        self.core = app._edb
         self._app = app
 
     @property
@@ -319,7 +316,7 @@ class NetClassDotNet:
         object
         """
         if self.api_object:
-            edb_api_net = self.edb_api.Cell.Net.FindByName(self._app.active_layout, name)
+            edb_api_net = self.core.Cell.Net.FindByName(self._app.active_layout, name)
             return self.api_object.AddNet(edb_api_net)
 
     def delete(self):  # pragma: no cover
@@ -379,8 +376,8 @@ class DifferentialPairDotNet(NetClassDotNet):
         return DifferentialPairDotNet(self._app, self.cell_diff_pair.Create(self._app.active_layout, name))
 
     def _api_set_differential_pair(self, net_name_p, net_name_n):
-        edb_api_net_p = self.edb_api.Cell.Net.FindByName(self._app.active_layout, net_name_p)
-        edb_api_net_n = self.edb_api.Cell.Net.FindByName(self._app.active_layout, net_name_n)
+        edb_api_net_p = self.core.Cell.Net.FindByName(self._app.active_layout, net_name_p)
+        edb_api_net_n = self.core.Cell.Net.FindByName(self._app.active_layout, net_name_n)
         self.api_object.SetDifferentialPair(edb_api_net_p, edb_api_net_n)
 
     @property
@@ -416,8 +413,8 @@ class CellClassDotNet:
 
     def __init__(self, app, active_cell=None):
         self._app = app
-        self.edb_api = app._edb
-        self._cell = self.edb_api.Cell
+        self.core = app._edb
+        self._cell = self.core.Cell
         self._active_cell = active_cell
 
     @property
@@ -519,7 +516,7 @@ class UtilityDotNet:
     def __init__(self, app):
         self._app = app
         self.utility = app._edb.Utility
-        self.edb_api = app._edb
+        self.core = app._edb
         self.active_db = app._db
         self.active_cell = app._active_cell
 
@@ -567,7 +564,7 @@ class GeometryDotNet:
     def __init__(self, app):
         self._app = app
         self.geometry = self._app._edb.Geometry
-        self.edb_api = self._app._edb
+        self.core = self._app._edb
 
     @property
     def api_class(self):
@@ -648,29 +645,29 @@ class CellDotNet:
             return super().__getattribute__(key)
         except AttributeError:
             try:
-                return getattr(self.edb_api, key)
+                return getattr(self.core, key)
             except AttributeError:
                 raise AttributeError("Attribute not present")
 
     def __init__(self, app):
         self._app = app
-        self.edb_api = app._edb
+        self.core = app._edb
 
     @property
     def api_class(self):
         """Return Ansys.Ansoft.Edb class object."""
-        return self.edb_api
+        return self.core
 
     @property
     def definition(self):
         """Edb Dotnet Api Definition."""
 
-        return self.edb_api.Definition
+        return self.core.Definition
 
     @property
     def database(self):
         """Edb Dotnet Api Database."""
-        return self.edb_api.Database
+        return self.core.Database
 
     @property
     def cell(self):
@@ -705,12 +702,7 @@ class EdbDotNet(object):
     """Edb Dot Net Class."""
 
     def __init__(self, edbversion, student_version=False):
-        if not edbversion:  # pragma: no cover
-            try:
-                edbversion = "20{}.{}".format(list_installed_ansysem()[0][-3:-1], list_installed_ansysem()[0][-1:])
-                self._logger.info("Edb version " + edbversion)
-            except IndexError:
-                raise Exception("No ANSYSEM_ROOTxxx is found.")
+        self._logger.info(f"Edb version {edbversion}")
         self.edbversion = edbversion
         if float(self.edbversion) >= 2025.2:
             warnings.warn(GRPC_GENERAL_WARNING, UserWarning)
@@ -797,6 +789,19 @@ class EdbDotNet(object):
     def edb_api(self):
         """Edb Dotnet Api class.
 
+        .. deprecated:: 0.54.0
+            Use :func:core` instead.
+        Returns
+        -------
+        :class:`pyedb.dotnet.database.dotnet.database.CellDotNet`
+        """
+        warnings.warn("`edb_api` is deprecated, use `core` instead.", DeprecationWarning)
+        return CellDotNet(self)
+
+    @property
+    def core(self):
+        """Edb Dotnet Api class.
+
         Returns
         -------
         :class:`pyedb.dotnet.database.dotnet.database.CellDotNet`
@@ -806,12 +811,12 @@ class EdbDotNet(object):
     @property
     def database(self):
         """Edb Dotnet Api Database."""
-        return self.edb_api.database
+        return self.core.database
 
     @property
     def definition(self):
         """Edb Dotnet Api Database `Edb.Definition`."""
-        return self.edb_api.Definition
+        return self.core.Definition
 
 
 class Database(EdbDotNet):
@@ -845,7 +850,7 @@ class Database(EdbDotNet):
         flag : bool
             Whether if Edb is run as standalone or embedded in AEDT.
         """
-        self.edb_api.database.SetRunAsStandAlone(flag)
+        self.core.database.SetRunAsStandAlone(flag)
 
     def create(self, db_path):
         """Create a Database at the specified file location.
@@ -859,7 +864,7 @@ class Database(EdbDotNet):
         -------
         Database
         """
-        self._db = self.edb_api.database.Create(db_path)
+        self._db = self.core.database.Create(db_path)
         return self._db
 
     def open(self, db_path, read_only):
@@ -877,7 +882,7 @@ class Database(EdbDotNet):
         Database or None
             The opened Database object, or None if not found.
         """
-        self._db = self.edb_api.database.Open(
+        self._db = self.core.database.Open(
             db_path,
             read_only,
         )
@@ -893,7 +898,7 @@ class Database(EdbDotNet):
         db_path : str
             Path to top-level database folder.
         """
-        return self.edb_api.database.Delete(db_path)
+        return self.core.database.Delete(db_path)
 
     def save(self):
         """Save any changes into a file."""
@@ -972,7 +977,7 @@ class Database(EdbDotNet):
         Database
             The Database or Null on failure.
         """
-        self.edb_api.database.FindById(db_id)
+        self.core.database.FindById(db_id)
 
     def save_as(self, path, version=""):
         """Save this Database to a new location and older EDB version.
@@ -1232,5 +1237,5 @@ class Database(EdbDotNet):
         from pyedb.dotnet.clr_module import Convert
 
         hdl = Convert.ToUInt64(hdb)
-        self._db = self.edb_api.database.Attach(hdl)
+        self._db = self.core.database.Attach(hdl)
         return self._db

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,
         )
@@ -146,7 +146,7 @@ class LayerEdbClass(object):
 
     @property
     def _edb(self):
-        return self._pedb.edb_api
+        return self._pedb.core
 
     @property
     def _edb_layer(self):
@@ -289,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),
@@ -639,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,
@@ -685,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.