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

pyedb/__init__.py

@@ -44,7 +44,7 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.53.0"
+__version__ = "0.54.0"
 version = __version__
 
 #

pyedb/configuration/cfg_ports_sources.py

@@ -58,7 +58,7 @@ class CfgTerminalInfo(CfgBase):
         self.contact_type = kwargs.get("contact_type", "default")  # options are full, center, quad, inline
         contact_radius = "0.1mm" if kwargs.get("contact_radius") is None else kwargs.get("contact_radius")
 
-        self.contact_radius = self._pedb.edb_value(contact_radius).ToDouble()
+        self.contact_radius = self._pedb.value(contact_radius)
         self.num_of_contact = kwargs.get("num_of_contact", 4)
         self.contact_expansion = kwargs.get("contact_expansion", 1)
 
@@ -678,11 +678,9 @@ class CfgEdgePort:
     def set_parameters_to_edb(self):
         point_on_edge = PointData(self._pedb, x=self.point_on_edge[0], y=self.point_on_edge[1])
         primitive = self._pedb.layout.primitives_by_aedt_name[self.primitive_name]
-        pos_edge = self._pedb.edb_api.cell.terminal.PrimitiveEdge.Create(
-            primitive._edb_object, point_on_edge._edb_object
-        )
-        pos_edge = convert_py_list_to_net_list(pos_edge, self._pedb.edb_api.cell.terminal.Edge)
-        edge_term = self._pedb.edb_api.cell.terminal.EdgeTerminal.Create(
+        pos_edge = self._pedb.core.cell.terminal.PrimitiveEdge.Create(primitive._edb_object, point_on_edge._edb_object)
+        pos_edge = convert_py_list_to_net_list(pos_edge, self._pedb.core.cell.terminal.Edge)
+        edge_term = self._pedb.core.cell.terminal.EdgeTerminal.Create(
             primitive._edb_object.GetLayout(),
             primitive._edb_object.GetNet(),
             self.name,
@@ -755,9 +753,9 @@ class CfgDiffWavePort:
         pos_term = self.positive_port.set_parameters_to_edb()
         neg_term = self.negative_port.set_parameters_to_edb()
         edb_list = convert_py_list_to_net_list(
-            [pos_term._edb_object, neg_term._edb_object], self._pedb.edb_api.cell.terminal.Terminal
+            [pos_term._edb_object, neg_term._edb_object], self._pedb.core.cell.terminal.Terminal
         )
-        _edb_boundle_terminal = self._pedb.edb_api.cell.terminal.BundleTerminal.Create(edb_list)
+        _edb_boundle_terminal = self._pedb.core.cell.terminal.BundleTerminal.Create(edb_list)
         _edb_boundle_terminal.SetName(self.name)
         pos, neg = list(_edb_boundle_terminal.GetTerminals())
         pos.SetName(self.name + ":T1")

pyedb/configuration/configuration.py

@@ -261,6 +261,7 @@ class Configuration:
 
     def get_variables(self):
         """Retrieve variables from database."""
+        self.cfg_data.variables.variables = []
         for name, obj in self._pedb.design_variables.items():
             self.cfg_data.variables.add_variable(name, obj.value_string, obj.description)
         for name, obj in self._pedb.project_variables.items():
@@ -422,7 +423,7 @@ class Configuration:
         if kwargs.get("general", False):
             data["general"] = self.cfg_data.general.get_data_from_db()
         if kwargs.get("variables", False):
-            data["variables"] = self.cfg_data.variables.model_dump(exclude_none=True)
+            data.update(self.cfg_data.variables.model_dump(exclude_none=True))
         if kwargs.get("stackup", False):
             data["stackup"] = self.cfg_data.stackup.model_dump(exclude_none=True)
         if kwargs.get("package_definitions", False):

pyedb/dotnet/database/cell/hierarchy/model.py

@@ -28,7 +28,7 @@ class Model(ObjBase):
 
     def __init__(self, pedb, edb_object):
         super().__init__(pedb, edb_object)
-        self._model_type_mapping = {"PinPairModel": self._pedb.edb_api.cell}
+        self._model_type_mapping = {"PinPairModel": self._pedb.core.cell}
 
     @property
     def model_type(self):

pyedb/dotnet/database/cell/layout.py

@@ -102,7 +102,7 @@ class Layout(ObjBase):
 
     @property
     def _edb(self):
-        return self._pedb.edb_api
+        return self._pedb.core
 
     def expanded_extent(self, nets, extent, expansion_factor, expansion_unitless, use_round_corner, num_increments):
         """Get an expanded polygon for the Nets collection.

pyedb/dotnet/database/cell/layout_obj.py

@@ -38,7 +38,7 @@ class LayoutObj(ObjBase):
         -------
         Ansys.Ansoft.Edb
         """
-        return self._pedb.edb_api
+        return self._pedb.core
 
     @property
     def _layout_obj_instance(self):
@@ -48,12 +48,12 @@ class LayoutObj(ObjBase):
 
     @property
     def _edb_properties(self):
-        p = self._edb_object.GetProductSolverOption(self._edb.edb_api.ProductId.Designer, "HFSS")
+        p = self._edb_object.GetProductSolverOption(self._edb.core.ProductId.Designer, "HFSS")
         return p
 
     @_edb_properties.setter
     def _edb_properties(self, value):
-        self._edb_object.SetProductSolverOption(self._edb.edb_api.ProductId.Designer, "HFSS", value)
+        self._edb_object.SetProductSolverOption(self._edb.core.ProductId.Designer, "HFSS", value)
 
     @property
     def _obj_type(self):

pyedb/dotnet/database/cell/primitive/path.py

@@ -155,7 +155,7 @@ class Path(Primitive):
         width = self.width
         corner_style = self.corner_style
         end_cap_style = self.get_end_cap_style()
-        cloned_path = self._app.edb_api.cell.primitive.path.create(
+        cloned_path = self._app.core.cell.primitive.path.create(
             self._app.active_layout,
             self.layer_name,
             self.net,

pyedb/dotnet/database/cell/primitive/primitive.py

@@ -264,10 +264,10 @@ class Primitive(Connectable):
         """
         bbox = self.polygon_data._edb_object.GetBBox()
         return [
-            round(bbox.Item1.X.ToDouble(), 6),
-            round(bbox.Item1.Y.ToDouble(), 6),
-            round(bbox.Item2.X.ToDouble(), 6),
-            round(bbox.Item2.Y.ToDouble(), 6),
+            round(bbox.Item1.X.ToDouble(), 9),
+            round(bbox.Item1.Y.ToDouble(), 9),
+            round(bbox.Item2.X.ToDouble(), 9),
+            round(bbox.Item2.Y.ToDouble(), 9),
         ]
 
     def convert_to_polygon(self):
@@ -336,7 +336,7 @@ class Primitive(Connectable):
         list of float
         """
         if isinstance(point, (list, tuple)):
-            point = self._app.edb_api.geometry.point_data(self._app.edb_value(point[0]), self._app.edb_value(point[1]))
+            point = self._app.core.geometry.point_data(self._app.edb_value(point[0]), self._app.edb_value(point[1]))
 
         p0 = self.polygon_data._edb_object.GetClosestPoint(point)
         return [p0.X.ToDouble(), p0.Y.ToDouble()]
@@ -540,7 +540,7 @@ class Primitive(Connectable):
         -------
         list of float
         """
-        if isinstance(point, self._app.edb_api.geometry.geometry.PointData):
+        if isinstance(point, self._app.core.geometry.geometry.PointData):
             point = [point.X.ToDouble(), point.Y.ToDouble()]
         dist = 1e12
         out = None
@@ -821,7 +821,7 @@ class Primitive(Connectable):
             r"$end 'EM properties'\n"
         )
 
-        pid = self._pedb.edb_api.ProductId.Designer
+        pid = self._pedb.core.ProductId.Designer
         _, p = self._edb_object.GetProductProperty(pid, 18, "")
         if p:
             return p
@@ -831,7 +831,7 @@ class Primitive(Connectable):
     @_em_properties.setter
     def _em_properties(self, em_prop):
         """Set EM properties"""
-        pid = self._pedb.edb_api.ProductId.Designer
+        pid = self._pedb.core.ProductId.Designer
         self._edb_object.SetProductProperty(pid, 18, em_prop)
 
     @property

pyedb/dotnet/database/cell/terminal/pingroup_terminal.py

@@ -48,7 +48,7 @@ class PinGroupTerminal(Terminal):
         :class:`pyedb.dotnet.database.edb_data.terminals.PinGroupTerminal`
         """
         net_obj = self._pedb.layout.find_net_by_name(net_name)
-        term = self._pedb.edb_api.cell.terminal.PinGroupTerminal.Create(
+        term = self._pedb.core.cell.terminal.PinGroupTerminal.Create(
             self._pedb.active_layout,
             net_obj._edb_object,
             name,

pyedb/dotnet/database/cell/terminal/point_terminal.py

@@ -50,7 +50,7 @@ class PointTerminal(Terminal):
         -------
         :class:`pyedb.dotnet.database.edb_data.terminals.PointTerminal`
         """
-        terminal = self._pedb.edb_api.cell.terminal.PointTerminal.Create(
+        terminal = self._pedb.core.cell.terminal.PointTerminal.Create(
             self._pedb.active_layout,
             self._pedb.layout.find_net_by_name(net)._edb_object,
             name,

pyedb/dotnet/database/cell/terminal/terminal.py

@@ -34,26 +34,26 @@ class Terminal(Connectable):
         self._reference_object = None
 
         self._boundary_type_mapping = {
-            "InvalidBoundary": self._pedb.edb_api.cell.terminal.BoundaryType.InvalidBoundary,
-            "PortBoundary": self._pedb.edb_api.cell.terminal.BoundaryType.PortBoundary,
-            "PecBoundary": self._pedb.edb_api.cell.terminal.BoundaryType.PecBoundary,
-            "RlcBoundary": self._pedb.edb_api.cell.terminal.BoundaryType.RlcBoundary,
-            "kCurrentSource": self._pedb.edb_api.cell.terminal.BoundaryType.kCurrentSource,
-            "kVoltageSource": self._pedb.edb_api.cell.terminal.BoundaryType.kVoltageSource,
-            "kNexximGround": self._pedb.edb_api.cell.terminal.BoundaryType.kNexximGround,
-            "kNexximPort": self._pedb.edb_api.cell.terminal.BoundaryType.kNexximPort,
-            "kDcTerminal": self._pedb.edb_api.cell.terminal.BoundaryType.kDcTerminal,
-            "kVoltageProbe": self._pedb.edb_api.cell.terminal.BoundaryType.kVoltageProbe,
+            "InvalidBoundary": self._pedb.core.cell.terminal.BoundaryType.InvalidBoundary,
+            "PortBoundary": self._pedb.core.cell.terminal.BoundaryType.PortBoundary,
+            "PecBoundary": self._pedb.core.cell.terminal.BoundaryType.PecBoundary,
+            "RlcBoundary": self._pedb.core.cell.terminal.BoundaryType.RlcBoundary,
+            "kCurrentSource": self._pedb.core.cell.terminal.BoundaryType.kCurrentSource,
+            "kVoltageSource": self._pedb.core.cell.terminal.BoundaryType.kVoltageSource,
+            "kNexximGround": self._pedb.core.cell.terminal.BoundaryType.kNexximGround,
+            "kNexximPort": self._pedb.core.cell.terminal.BoundaryType.kNexximPort,
+            "kDcTerminal": self._pedb.core.cell.terminal.BoundaryType.kDcTerminal,
+            "kVoltageProbe": self._pedb.core.cell.terminal.BoundaryType.kVoltageProbe,
         }
 
         self._terminal_type_mapping = {
-            "InvalidTerminal": self._pedb.edb_api.cell.terminal.TerminalType.InvalidTerminal,
-            "EdgeTerminal": self._pedb.edb_api.cell.terminal.TerminalType.EdgeTerminal,
-            "PointTerminal": self._pedb.edb_api.cell.terminal.TerminalType.PointTerminal,
-            "TerminalInstanceTerminal": self._pedb.edb_api.cell.terminal.TerminalType.TerminalInstanceTerminal,
-            "PadstackInstanceTerminal": self._pedb.edb_api.cell.terminal.TerminalType.PadstackInstanceTerminal,
-            "BundleTerminal": self._pedb.edb_api.cell.terminal.TerminalType.BundleTerminal,
-            "PinGroupTerminal": self._pedb.edb_api.cell.terminal.TerminalType.PinGroupTerminal,
+            "InvalidTerminal": self._pedb.core.cell.terminal.TerminalType.InvalidTerminal,
+            "EdgeTerminal": self._pedb.core.cell.terminal.TerminalType.EdgeTerminal,
+            "PointTerminal": self._pedb.core.cell.terminal.TerminalType.PointTerminal,
+            "TerminalInstanceTerminal": self._pedb.core.cell.terminal.TerminalType.TerminalInstanceTerminal,
+            "PadstackInstanceTerminal": self._pedb.core.cell.terminal.TerminalType.PadstackInstanceTerminal,
+            "BundleTerminal": self._pedb.core.cell.terminal.TerminalType.BundleTerminal,
+            "PinGroupTerminal": self._pedb.core.cell.terminal.TerminalType.PinGroupTerminal,
         }
 
     @property
@@ -240,10 +240,10 @@ class Terminal(Connectable):
         if not self._reference_object:
             term = self._edb_object
 
-            if self.terminal_type == self._pedb.edb_api.cell.terminal.TerminalType.EdgeTerminal:
+            if self.terminal_type == self._pedb.core.cell.terminal.TerminalType.EdgeTerminal:
                 edges = self._edb_object.GetEdges()
                 edgeType = edges[0].GetEdgeType()
-                if edgeType == self._pedb.edb_api.cell.terminal.EdgeType.PadEdge:
+                if edgeType == self._pedb.core.cell.terminal.EdgeType.PadEdge:
                     self._reference_object = self.get_pad_edge_terminal_reference_pin()
                 else:
                     self._reference_object = self.get_edge_terminal_reference_primitive()
@@ -304,16 +304,14 @@ class Terminal(Connectable):
         """
 
         refTerm = self._edb_object.GetReferenceTerminal()
-        if self._edb_object.GetTerminalType() == self._pedb.edb_api.cell.terminal.TerminalType.PinGroupTerminal:
+        if self._edb_object.GetTerminalType() == self._pedb.core.cell.terminal.TerminalType.PinGroupTerminal:
             padStackInstance = self._edb_object.GetPinGroup().GetPins()[0]
             pingroup = refTerm.GetPinGroup()
             refPinList = pingroup.GetPins()
             return self._get_closest_pin(padStackInstance, refPinList, gnd_net_name_preference)
-        elif (
-            self._edb_object.GetTerminalType() == self._pedb.edb_api.cell.terminal.TerminalType.PadstackInstanceTerminal
-        ):
+        elif self._edb_object.GetTerminalType() == self._pedb.core.cell.terminal.TerminalType.PadstackInstanceTerminal:
             _, padStackInstance, _ = self._edb_object.GetParameters()
-            if refTerm.GetTerminalType() == self._pedb.edb_api.cell.terminal.TerminalType.PinGroupTerminal:
+            if refTerm.GetTerminalType() == self._pedb.core.cell.terminal.TerminalType.PinGroupTerminal:
                 pingroup = refTerm.GetPinGroup()
                 refPinList = pingroup.GetPins()
                 return self._get_closest_pin(padStackInstance, refPinList, gnd_net_name_preference)
@@ -339,7 +337,7 @@ class Terminal(Connectable):
         _, _, point_data = edges[0].GetParameters()
         X = point_data.X
         Y = point_data.Y
-        shape_pd = self._pedb.edb_api.geometry.point_data(X, Y)
+        shape_pd = self._pedb.core.geometry.point_data(X, Y)
         layer_name = ref_layer.GetName()
         for primitive in self._pedb.layout.primitives:
             if primitive.GetLayer().GetName() == layer_name or not layer_name:
@@ -361,7 +359,7 @@ class Terminal(Connectable):
         _, point_data, layer = ref_term.GetParameters()
         X = point_data.X
         Y = point_data.Y
-        shape_pd = self._pedb.edb_api.geometry.point_data(X, Y)
+        shape_pd = self._pedb.core.geometry.point_data(X, Y)
         layer_name = layer.GetName()
         for primitive in self._pedb.layout.primitives:
             if primitive.GetLayer().GetName() == layer_name:

pyedb/dotnet/database/components.py

@@ -125,7 +125,7 @@ class Components(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)
@@ -496,7 +496,7 @@ class Components(object):
         return cmp_list
 
     def _get_edb_pin_from_pin_name(self, cmp, pin):
-        if not isinstance(cmp, self._pedb.edb_api.cell.hierarchy.component):
+        if not isinstance(cmp, self._pedb.core.cell.hierarchy.component):
             return False
         if not isinstance(pin, str):
             pin = pin.GetName()
@@ -619,7 +619,7 @@ class Components(object):
 
         """
         if cmp is not None:
-            if not (isinstance(cmp, self._pedb.edb_api.cell.hierarchy.component)):
+            if not (isinstance(cmp, self._pedb.core.cell.hierarchy.component)):
                 cmp = self.get_component_by_name(cmp)
             cmp_prop = cmp.GetComponentProperty().Clone()
             return cmp_prop.GetSolderBallProperty().GetHeight()
@@ -1316,7 +1316,7 @@ class Components(object):
         pins = self.get_pin_from_component(component.refdes)
         if len(pins) == 2:  # pragma: no cover
             pin_layers = self._padstack._get_pin_layer_range(pins[0])
-            pos_pin_term = self._pedb.edb_api.cell.terminal.PadstackInstanceTerminal.Create(
+            pos_pin_term = self._pedb.core.cell.terminal.PadstackInstanceTerminal.Create(
                 self._active_layout,
                 pins[0].net._edb_object,
                 f"{component.refdes}_{pins[0]._edb_object.GetName()}",
@@ -1326,7 +1326,7 @@ class Components(object):
             )
             if not pos_pin_term:  # pragma: no cover
                 return False
-            neg_pin_term = self._pedb.edb_api.cell.terminal.PadstackInstanceTerminal.Create(
+            neg_pin_term = self._pedb.core.cell.terminal.PadstackInstanceTerminal.Create(
                 self._active_layout,
                 pins[1].net._edb_object,
                 f"{component.refdes}_{pins[1]._edb_object.GetName()}_ref",
@@ -1337,11 +1337,11 @@ class Components(object):
             if not neg_pin_term:  # pragma: no cover
                 return False
             if pec_boundary:
-                pos_pin_term.SetBoundaryType(self._pedb.edb_api.cell.terminal.BoundaryType.PecBoundary)
-                neg_pin_term.SetBoundaryType(self._pedb.edb_api.cell.terminal.BoundaryType.PecBoundary)
+                pos_pin_term.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.PecBoundary)
+                neg_pin_term.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.PecBoundary)
             else:
-                pos_pin_term.SetBoundaryType(self._pedb.edb_api.cell.terminal.BoundaryType.PortBoundary)
-                neg_pin_term.SetBoundaryType(self._pedb.edb_api.cell.terminal.BoundaryType.PortBoundary)
+                pos_pin_term.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.PortBoundary)
+                neg_pin_term.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.PortBoundary)
             pos_pin_term.SetName(component.refdes)
             pos_pin_term.SetReferenceTerminal(neg_pin_term)
             if circuit_ports and not pec_boundary:
@@ -1382,7 +1382,7 @@ class Components(object):
         pins = self.get_pin_from_component(component.refdes)
         if len(pins) == 2:  # pragma: no cover
             pin_layer = self._padstack._get_pin_layer_range(pins[0])[0]
-            pos_pin_term = self._pedb.edb_api.cell.terminal.PadstackInstanceTerminal.Create(
+            pos_pin_term = self._pedb.core.cell.terminal.PadstackInstanceTerminal.Create(
                 self._active_layout,
                 pins[0]._edb_object.GetNet(),
                 f"{component.refdes}_{pins[0]._edb_object.GetName()}",
@@ -1392,7 +1392,7 @@ class Components(object):
             )
             if not pos_pin_term:  # pragma: no cover
                 return False
-            neg_pin_term = self._pedb.edb_api.cell.terminal.PadstackInstanceTerminal.Create(
+            neg_pin_term = self._pedb.core.cell.terminal.PadstackInstanceTerminal.Create(
                 self._active_layout,
                 pins[1]._edb_object.GetNet(),
                 f"{component.refdes}_{pins[1]._edb_object.GetName()}_ref",
@@ -1402,13 +1402,13 @@ class Components(object):
             )
             if not neg_pin_term:  # pragma: no cover
                 return False
-            pos_pin_term.SetBoundaryType(self._pedb.edb_api.cell.terminal.BoundaryType.RlcBoundary)
+            pos_pin_term.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.RlcBoundary)
             if not circuit_type:
                 pos_pin_term.SetIsCircuitPort(False)
             else:
                 pos_pin_term.SetIsCircuitPort(True)
             pos_pin_term.SetName(component.refdes)
-            neg_pin_term.SetBoundaryType(self._pedb.edb_api.cell.terminal.BoundaryType.RlcBoundary)
+            neg_pin_term.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.RlcBoundary)
             if not circuit_type:
                 neg_pin_term.SetIsCircuitPort(False)
             else:
@@ -1488,9 +1488,9 @@ class Components(object):
             return False
 
     def _getComponentDefinition(self, name, pins):
-        componentDefinition = self._pedb.edb_api.definition.ComponentDef.FindByName(self._db, name)
+        componentDefinition = self._pedb.core.definition.ComponentDef.FindByName(self._db, name)
         if componentDefinition.IsNull():
-            componentDefinition = self._pedb.edb_api.definition.ComponentDef.Create(self._db, name, None)
+            componentDefinition = self._pedb.core.definition.ComponentDef.Create(self._db, name, None)
             if componentDefinition.IsNull():
                 self._logger.error("Failed to create component definition {}".format(name))
                 return None
@@ -1499,7 +1499,7 @@ class Components(object):
                 if not pin.GetName():
                     pin.SetName(str(ind))
                 ind += 1
-                componentDefinitionPin = self._pedb.edb_api.definition.ComponentDefPin.Create(
+                componentDefinitionPin = self._pedb.core.definition.ComponentDefPin.Create(
                     componentDefinition, pin.GetName()
                 )
                 if componentDefinitionPin.IsNull():
@@ -1614,7 +1614,7 @@ class Components(object):
             compdef = self._getComponentDefinition(component_name, pins)
         if not compdef:
             return False
-        new_cmp = self._pedb.edb_api.cell.hierarchy.component.Create(
+        new_cmp = self._pedb.core.cell.hierarchy.component.Create(
             self._active_layout, component_name, compdef.GetName()
         )
 
@@ -2053,7 +2053,7 @@ class Components(object):
         >>> edbapp.components.set_solder_ball("A1")
 
         """
-        if not isinstance(component, self._pedb.edb_api.cell.hierarchy.component):
+        if not isinstance(component, self._pedb.core.cell.hierarchy.component):
             edb_cmp = self.get_component_by_name(component)._edb_object
             cmp = self.instances[component]
         else:  # pragma: no cover
@@ -2388,7 +2388,7 @@ class Components(object):
         reference_designator : str
             Reference designator of the component.
         """
-        obj = self._pedb.edb_api.cell.hierarchy.component.FindByName(self._active_layout, reference_designator)
+        obj = self._pedb.core.cell.hierarchy.component.FindByName(self._active_layout, reference_designator)
         return EDBComponent(self._pedb, obj)
 
     def get_pin_from_component(self, component, netName=None, pinName=None, net_name=None, pin_name=None):
@@ -2427,8 +2427,8 @@ class Components(object):
 
         """
         warnings.warn("Use new property :func:`edb.padstacks.get_instances` instead.", DeprecationWarning)
-        if not isinstance(component, self._pedb.edb_api.cell.hierarchy.component):
-            component = self._pedb.edb_api.cell.hierarchy.component.FindByName(self._active_layout, component)
+        if not isinstance(component, self._pedb.core.cell.hierarchy.component):
+            component = self._pedb.core.cell.hierarchy.component.FindByName(self._active_layout, component)
         if pinName:
             warnings.warn("Use argument `pin_name` instead of `pinName`", DeprecationWarning)
         if netName:
@@ -2490,7 +2490,7 @@ class Components(object):
         if isinstance(pin, EDBPadstackInstance):
             pin = pin._edb_padstackinstance
         val = String("")
-        _, name = pin.GetProductProperty(self._edb.edb_api.ProductId.Designer, 11, val)
+        _, name = pin.GetProductProperty(self._edb.core.ProductId.Designer, 11, val)
         name = str(name).strip("'")
         return name
 
@@ -2766,8 +2766,8 @@ class Components(object):
             elif pars:
                 delta_pins.append(1.5 * pars[0])
                 w = min(pars[0], w)
-            elif pad.polygon_data.edb_api:  # pragma: no cover
-                bbox = pad.polygon_data.edb_api.GetBBox()
+            elif pad.polygon_data.core:  # pragma: no cover
+                bbox = pad.polygon_data.core.GetBBox()
                 lower = [bbox.Item1.X.ToDouble(), bbox.Item1.Y.ToDouble()]
                 upper = [bbox.Item2.X.ToDouble(), bbox.Item2.Y.ToDouble()]
                 pars = [abs(lower[0] - upper[0]), abs(lower[1] - upper[1])]

pyedb/dotnet/database/definition/component_def.py

@@ -88,7 +88,7 @@ class EDBComponentDef(ObjBase):
 
         comp_list = [
             EDBComponent(self._pedb, l)
-            for l in self._pedb.edb_api.cell.hierarchy.component.FindByComponentDef(
+            for l in self._pedb.core.cell.hierarchy.component.FindByComponentDef(
                 self._pedb.active_layout, self.part_name
             )
         ]
@@ -194,9 +194,9 @@ class EDBComponentDef(ObjBase):
         self._add_component_model(n_port_comp_model)
 
     def create(self, name):
-        cell_type = self._pedb.edb_api.cell.CellType.FootprintCell
+        cell_type = self._pedb.core.cell.CellType.FootprintCell
         footprint_cell = self._pedb._active_cell.cell.Create(self._pedb.active_db, cell_type, name)
-        edb_object = self._pedb.edb_api.definition.ComponentDef.Create(self._pedb.active_db, name, footprint_cell)
+        edb_object = self._pedb.core.definition.ComponentDef.Create(self._pedb.active_db, name, footprint_cell)
         return EDBComponentDef(self._pedb, edb_object)
 
     def get_properties(self):

pyedb/dotnet/database/definition/component_model.py

@@ -28,7 +28,7 @@ class ComponentModel(ObjBase):
 
     def __init__(self, pedb, edb_object):
         super().__init__(pedb, edb_object)
-        self._model_type_mapping = {"PinPairModel": self._pedb.edb_api.cell}
+        self._model_type_mapping = {"PinPairModel": self._pedb.core.cell}
 
 
 class NPortComponentModel(ComponentModel):

pyedb/dotnet/database/definition/package_def.py

@@ -62,7 +62,7 @@ class PackageDef(ObjBase):
         edb_object: object
             EDB PackageDef Object
         """
-        edb_object = self._pedb.edb_api.definition.PackageDef.Create(self._pedb.active_db, name)
+        edb_object = self._pedb.core.definition.PackageDef.Create(self._pedb.active_db, name)
         if component_part_name:
             x_pt1, y_pt1, x_pt2, y_pt2 = list(
                 self._pedb.components.definitions[component_part_name].components.values()