pyedb 0.18.0__py3-none-any.whl → 0.20.0__py3-none-any.whl

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

@@ -22,7 +22,7 @@
 
 import re
 
-from pyedb.dotnet.edb_core.cell.layout_obj import Connectable
+from pyedb.dotnet.edb_core.cell.connectable import Connectable
 from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
 from pyedb.dotnet.edb_core.edb_data.primitives_data import cast
 
@@ -159,24 +159,6 @@ class Terminal(Connectable):
         ppp.DoRenormalize = value
         self._port_post_processing_prop = ppp
 
-    @property
-    def name(self):
-        """Port Name.
-
-        Returns
-        -------
-        str
-        """
-        return self._edb_object.GetName()
-
-    @name.setter
-    def name(self, value):
-        if isinstance(value, str):
-            if not any(port for port in list(self._pedb.excitations.keys()) if port == value):
-                self._edb_object.SetName(value)
-            else:
-                self._pedb.logger.warning("An existing port already has this same name. A port name must be unique.")
-
     @property
     def net_name(self):
         """Net name.
@@ -217,6 +199,21 @@ class Terminal(Connectable):
     def boundary_type(self, value):
         self._edb_object.SetBoundaryType(self._boundary_type_mapping[value])
 
+    @property
+    def is_port(self):
+        """Whether it is a port."""
+        return True if self.boundary_type == "PortBoundary" else False
+
+    @property
+    def is_current_source(self):
+        """Whether it is a current source."""
+        return True if self.boundary_type == "kCurrentSource" else False
+
+    @property
+    def is_voltage_source(self):
+        """Whether it is a voltage source."""
+        return True if self.boundary_type == "kVoltageSource" else False
+
     @property
     def impedance(self):
         """Impedance of the port."""
@@ -235,7 +232,8 @@ class Terminal(Connectable):
     def ref_terminal(self):
         """Get reference terminal."""
 
-        terminal = Terminal(self._pedb, self._edb_object.GetReferenceTerminal())
+        edb_terminal = self._edb_object.GetReferenceTerminal()
+        terminal = self._pedb.terminals[edb_terminal.GetName()]
         if not terminal.is_null:
             return terminal
 
@@ -444,3 +442,21 @@ class Terminal(Connectable):
                 pin_obj = pin
         if pin_obj:
             return EDBPadstackInstance(pin_obj, self._pedb)
+
+    @property
+    def magnitude(self):
+        """Get the magnitude of the source."""
+        return self._edb_object.GetSourceAmplitude().ToDouble()
+
+    @magnitude.setter
+    def magnitude(self, value):
+        self._edb_object.SetSourceAmplitude(self._edb.utility.value(value))
+
+    @property
+    def phase(self):
+        """Get the phase of the source."""
+        return self._edb_object.GetSourcePhase().ToDouble()
+
+    @phase.setter
+    def phase(self, value):
+        self._edb_object.SetSourcePhase(self._edb.utility.value(value))

pyedb/dotnet/edb_core/cell/voltage_regulator.py

@@ -20,7 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from pyedb.dotnet.edb_core.cell.layout_obj import Connectable
+from pyedb.dotnet.edb_core.cell.connectable import Connectable
 from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
 
 
@@ -49,7 +49,7 @@ class VoltageRegulator(Connectable):
         if value not in self._pedb.components.instances:
             self._pedb.logger.error(f"component {value} not found in layout")
             return
-        self._edb_object.SetGroup(self._pedb.components.instances[value].edbcomponent)
+        self._edb_object.SetGroup(self._pedb.components.instances[value]._edb_object)
 
     @property
     def load_regulator_current(self):
@@ -71,16 +71,6 @@ class VoltageRegulator(Connectable):
         _value = self._edb_object.edb_value(value)
         self._edb_object.SetLoadRegulationPercent(_value)
 
-    @property
-    def name(self):
-        """Retrieve voltage regulator name."""
-        return self._edb_object.GetName()
-
-    @name.setter
-    def name(self, value):
-        if isinstance(value, str):
-            self._edb_object.SetName(value)
-
     @property
     def negative_remote_sense_pin(self):
         """Retrieve negative remote sense pin."""
@@ -137,7 +127,3 @@ class VoltageRegulator(Connectable):
     def is_active(self, value):
         if isinstance(value, bool):
             self._edb_object.SetIsActive(value)
-
-    @property
-    def is_null(self):
-        return self._edb_object.IsNull()

pyedb/dotnet/edb_core/components.py

@@ -305,11 +305,10 @@ class Components(object):
     def refresh_components(self):
         """Refresh the component dictionary."""
         # self._logger.info("Refreshing the Components dictionary.")
-        self._cmp = {
-            l.GetName(): EDBComponent(self._pedb, l)
-            for l in self._layout.groups
-            if l.ToString() == "Ansys.Ansoft.Edb.Cell.Hierarchy.Component"
-        }
+        self._cmp = {}
+        for i in self._pedb.layout.groups:
+            if i.group_type == "component":
+                self._cmp[i.name] = i
         return True
 
     @property
@@ -487,11 +486,7 @@ class Components(object):
             ``True`` when successful, ``False`` when failed.
 
         """
-        edbcmp = self._pedb.edb_api.cell.hierarchy.component.FindByName(self._active_layout, name)
-        if edbcmp is not None:
-            return edbcmp
-        else:
-            pass
+        return self._pedb.layout.find_component_by_name(name)
 
     def get_components_from_nets(self, netlist=None):
         """Retrieve components from a net list.
@@ -675,9 +670,11 @@ class Components(object):
             positive_pin_group = self.create_pingroup_from_pins(positive_pins)
             if not positive_pin_group:  # pragma: no cover
                 return False
+            positive_pin_group = self._pedb.siwave.pin_groups[positive_pin_group.GetName()]
             negative_pin_group = self.create_pingroup_from_pins(negative_pins)
             if not negative_pin_group:  # pragma: no cover
                 return False
+            negative_pin_group = self._pedb.siwave.pin_groups[negative_pin_group.GetName()]
             if source.source_type == SourceType.Vsource:  # pragma: no cover
                 positive_pin_group_term = self._create_pin_group_terminal(
                     positive_pin_group,
@@ -766,20 +763,44 @@ class Components(object):
         >>> edb.close_edb()
         """
 
-        if isinstance(pins, str) or isinstance(pins, EDBPadstackInstance):
+        if isinstance(pins, str):
             pins = [pins]
+        elif isinstance(pins, EDBPadstackInstance):
+            pins = [pins.name]
         if isinstance(reference_pins, str):
             reference_pins = [reference_pins]
-        if isinstance(refdes, str) or isinstance(refdes, EDBComponent):
+        if isinstance(reference_pins, list):
+            _temp = []
+            for ref_pin in reference_pins:
+                if isinstance(ref_pin, int):
+                    if ref_pin in self._padstack.instances:
+                        _temp.append(self._padstack.instances[ref_pin])
+                elif isinstance(ref_pin, str):
+                    if ref_pin in self.instances[refdes].pins:
+                        _temp.append(self.instances[refdes].pins[ref_pin])
+                    else:
+                        p = [pp for pp in list(self._padstack.instances.values()) if pp.name == ref_pin]
+                        if p:
+                            _temp.append(p)
+                elif isinstance(ref_pin, EDBPadstackInstance):
+                    _temp.append(ref_pin.name)
+            reference_pins = _temp
+        elif isinstance(reference_pins, int):
+            if reference_pins in self._padstack.instances:
+                reference_pins = self._padstack.instances[reference_pins]
+        if isinstance(refdes, str):
             refdes = self.instances[refdes]
+        elif isinstance(refdes, self._pedb._edb.Cell.Hierarchy.Component):
+            refdes = EDBComponent(self._pedb, refdes)
+        refdes_pins = refdes.pins
         if any(refdes.rlc_values):
             return self.deactivate_rlc_component(component=refdes, create_circuit_port=True)
         if len([pin for pin in pins if isinstance(pin, str)]) == len(pins):
             cmp_pins = []
             for pin_name in pins:
-                cmp_pin = [pin for pin in list(refdes.pins.values()) if pin_name == pin.name]
+                cmp_pin = [pin for pin in list(refdes_pins.values()) if pin_name == pin.name]
                 if not cmp_pin:
-                    cmp_pin = [pin for pin in list(refdes.pins.values()) if pin_name == pin.name.split("-")[1]]
+                    cmp_pin = [pin for pin in list(refdes_pins.values()) if pin_name == pin.name.split("-")[1]]
                 if cmp_pin:
                     cmp_pins.append(cmp_pin[0])
             if not cmp_pins:
@@ -793,15 +814,15 @@ class Components(object):
         if len([pin for pin in reference_pins if isinstance(pin, str)]) == len(reference_pins):
             ref_cmp_pins = []
             for ref_pin_name in reference_pins:
-                cmp_ref_pin = [pin for pin in list(refdes.pins.values()) if ref_pin_name == pin.name]
-                if not cmp_ref_pin:
-                    cmp_ref_pin = [pin for pin in list(refdes.pins.values()) if ref_pin_name == pin.name.split("-")[1]]
-                if cmp_ref_pin:
-                    ref_cmp_pins.append(cmp_ref_pin[0])
+                if ref_pin_name in refdes_pins:
+                    ref_cmp_pins.append(refdes_pins[ref_pin_name])
+                elif "-" in ref_pin_name and ref_pin_name.split("-")[1] in refdes_pins:
+                    ref_cmp_pins.append(refdes_pins[ref_pin_name.split("-")[1]])
             if not ref_cmp_pins:
                 return
             reference_pins = ref_cmp_pins
-        if not len([pin for pin in reference_pins if isinstance(pin, EDBPadstackInstance)]) == len(reference_pins):
+        if not reference_pins:
+            self._logger.error("No reference pins found.")
             return
         if len(pins) > 1:
             pec_boundary = False
@@ -824,7 +845,9 @@ class Components(object):
             )
             ref_group_name = "group_{}_ref".format(port_name)
             ref_pin_group = self.create_pingroup_from_pins(reference_pins, ref_group_name)
+            ref_pin_group = self._pedb.siwave.pin_groups[ref_pin_group.GetName()]
             ref_term = self._create_pin_group_terminal(pingroup=ref_pin_group, term_name=port_name + "_ref")
+
         else:
             ref_term = self._create_terminal(reference_pins[0].primitive_object, term_name=port_name + "_ref")
         ref_term.SetIsCircuitPort(True)
@@ -883,7 +906,7 @@ class Components(object):
         solder_balls_size : float, optional
             Solder balls diameter. When provided auto evaluation based on padstack size will be disabled.
         solder_balls_mid_size : float, optional
-            Solder balls mid diameter. When provided if value is different than solder balls size, spheroid shape will
+            Solder balls mid-diameter. When provided if value is different than solder balls size, spheroid shape will
             be switched.
 
         Returns
@@ -904,11 +927,11 @@ class Components(object):
         if isinstance(component, str):
             component = self.instances[component].edbcomponent
         if not solder_balls_height:
-            solder_balls_height = self.components[component.GetName()].solder_ball_height
+            solder_balls_height = self.instances[component.GetName()].solder_ball_height
         if not solder_balls_size:
-            solder_balls_size = self.components[component.GetName()].solder_ball_diameter[0]
+            solder_balls_size = self.instances[component.GetName()].solder_ball_diameter[0]
         if not solder_balls_mid_size:
-            solder_balls_mid_size = self.components[component.GetName()].solder_ball_diameter[1]
+            solder_balls_mid_size = self.instances[component.GetName()].solder_ball_diameter[1]
         if not isinstance(net_list, list):
             net_list = [net_list]
         for net in net_list:
@@ -934,6 +957,18 @@ class Components(object):
             return False
         pin_layers = cmp_pins[0].GetPadstackDef().GetData().GetLayerNames()
         if port_type == SourceType.CoaxPort:
+            ref_pins = [
+                p
+                for p in list(component.LayoutObjs)
+                if int(p.GetObjType()) == 1 and p.GetNet().GetName() in reference_net
+            ]
+            if not ref_pins:
+                self._logger.error(
+                    "No reference pins found on component. You might consider"
+                    "using Circuit port instead since reference pins can be extended"
+                    "outside the component automatically when not found."
+                )
+                return False
             pad_params = self._padstack.get_pad_parameters(pin=cmp_pins[0], layername=pin_layers[0], pad_type=0)
             if not pad_params[0] == 7:
                 if not solder_balls_size:  # pragma no cover
@@ -981,17 +1016,26 @@ class Components(object):
             for p in ref_pins:
                 if not p.IsLayoutPin():
                     p.SetIsLayoutPin(True)
-            if len(ref_pins) == 0:
-                self._logger.info("No reference pin found on component {}.".format(component.GetName()))
+            if not ref_pins:
+                self._logger.warning("No reference pins found on component, the closest pin will be selected.")
+                do_pingroup = False
             if do_pingroup:
                 if len(ref_pins) == 1:
+                    ref_pins.is_pin = True
                     ref_pin_group_term = self._create_terminal(ref_pins[0])
                 else:
+                    for pin in ref_pins:
+                        pin.is_pin = True
                     ref_pin_group = self.create_pingroup_from_pins(ref_pins)
                     if not ref_pin_group:
+                        self._logger.error(f"Failed to create reference pin group on component {component.GetName()}.")
                         return False
-                    ref_pin_group_term = self._create_pin_group_terminal(ref_pin_group, isref=True)
+                    ref_pin_group = self._pedb.siwave.pin_groups[ref_pin_group.GetName()]
+                    ref_pin_group_term = self._create_pin_group_terminal(ref_pin_group, isref=False)
                     if not ref_pin_group_term:
+                        self._logger.error(
+                            f"Failed to create reference pin group terminal on component {component.GetName()}"
+                        )
                         return False
                 for net in net_list:
                     pins = [pin for pin in cmp_pins if pin.GetNet().GetName() == net]
@@ -1004,6 +1048,7 @@ class Components(object):
                             pin_group = self.create_pingroup_from_pins(pins)
                             if not pin_group:
                                 return False
+                            pin_group = self._pedb.siwave.pin_groups[pin_group.GetName()]
                             pin_group_term = self._create_pin_group_terminal(pin_group)
                             if pin_group_term:
                                 pin_group_term.SetReferenceTerminal(ref_pin_group_term)
@@ -1013,7 +1058,19 @@ class Components(object):
                 for net in net_list:
                     pins = [pin for pin in cmp_pins if pin.GetNet().GetName() == net]
                     for pin in pins:
-                        self.create_port_on_pins(component, pin, ref_pins)
+                        if ref_pins:
+                            self.create_port_on_pins(component, pin, ref_pins)
+                        else:
+                            _pin = EDBPadstackInstance(pin, self._pedb)
+                            ref_pin = _pin.get_reference_pins(
+                                reference_net=reference_net[0], max_limit=1, component_only=False, search_radius=3e-3
+                            )
+                            if ref_pin:
+                                self.create_port_on_pins(
+                                    component,
+                                    [EDBPadstackInstance(pin, self._pedb).name],
+                                    [EDBPadstackInstance(ref_pin[0], self._pedb).id],
+                                )
         return True
 
     def _create_terminal(self, pin, term_name=None):
@@ -1334,14 +1391,14 @@ class Components(object):
         -------
         Edb pin group terminal.
         """
-        pin = list(pingroup.GetPins())[0]
+        pin = list(pingroup._edb_object.GetPins())[0]
         if term_name is None:
             term_name = "{}.{}.{}".format(pin.GetComponent().GetName(), pin.GetName(), pin.GetNet().GetName())
         for t in list(self._pedb.active_layout.Terminals):
             if t.GetName() == term_name:
                 return t
         pingroup_term = self._edb.cell.terminal.PinGroupTerminal.Create(
-            self._active_layout, pingroup.GetNet(), term_name, pingroup, isref
+            self._active_layout, pingroup._edb_object.GetNet(), term_name, pingroup._edb_object, isref
         )
         if term_type == "circuit":
             pingroup_term.SetIsCircuitPort(True)
@@ -1929,7 +1986,7 @@ class Components(object):
 
         """
         if not isinstance(component, self._pedb.edb_api.cell.hierarchy.component):
-            edb_cmp = self.get_component_by_name(component)
+            edb_cmp = self.get_component_by_name(component)._edb_object
             cmp = self.instances[component]
         else:  # pragma: no cover
             edb_cmp = component

pyedb/dotnet/edb_core/dotnet/database.py

@@ -32,7 +32,6 @@ from pyedb.generic.general_methods import (
     env_path,
     env_path_student,
     env_value,
-    is_ironpython,
     is_linux,
     settings,
 )
@@ -751,14 +750,10 @@ class EdbDotNet(object):
                         self.base_path = edb_path
                         sys.path.append(edb_path)
                         os.environ[env_value(self.edbversion)] = self.base_path
-            if is_ironpython:
-                _clr.AddReferenceToFile("Ansys.Ansoft.Edb.dll")
-                _clr.AddReferenceToFile("Ansys.Ansoft.EdbBuilderUtils.dll")
-                _clr.AddReferenceToFileAndPath(os.path.join(self.base_path, "Ansys.Ansoft.SimSetupData.dll"))
-            else:
-                _clr.AddReference("Ansys.Ansoft.Edb")
-                _clr.AddReference("Ansys.Ansoft.EdbBuilderUtils")
-                _clr.AddReference("Ansys.Ansoft.SimSetupData")
+
+            _clr.AddReference("Ansys.Ansoft.Edb")
+            _clr.AddReference("Ansys.Ansoft.EdbBuilderUtils")
+            _clr.AddReference("Ansys.Ansoft.SimSetupData")
         else:
             if settings.edb_dll_path:
                 self.base_path = settings.edb_dll_path
@@ -1234,7 +1229,7 @@ class Database(EdbDotNet):
         -------
 
         """
-        from pyedb.generic.clr_module import Convert
+        from pyedb.dotnet.clr_module import Convert
 
         hdl = Convert.ToUInt64(hdb)
         self._db = self.edb_api.database.Attach(hdl)

pyedb/dotnet/edb_core/dotnet/primitive.py

@@ -96,7 +96,17 @@ class PrimitiveDotNet:
         _, name = self.prim_obj.GetProductProperty(self._app._edb.ProductId.Designer, 1, val)
         name = str(name).strip("'")
         if name == "":
-            name = "{}__{}".format(self.primitive_type, self.id)
+            if str(self.primitive_type) == "Path":
+                ptype = "line"
+            elif str(self.primitive_type) == "Rectangle":
+                ptype = "rect"
+            elif str(self.primitive_type) == "Polygon":
+                ptype = "poly"
+            elif str(self.primitive_type) == "Bondwire":
+                ptype = "bwr"
+            else:
+                ptype = str(self.primitive_type).lower()
+            name = "{}_{}".format(ptype, self.id)
             self.prim_obj.SetProductProperty(self._app._edb.ProductId.Designer, 1, name)
         return name
 
@@ -837,9 +847,8 @@ class PathDotNet(PrimitiveDotNet):
             net = net.api_object
         width = self._app.edb_api.utility.value(width)
         if isinstance(points, list):
-            points = self._app.edb_api.geometry.polygon_data.api_class(
-                convert_py_list_to_net_list([self._app.geometry.point_data(i) for i in points]), False
-            )
+            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)
         return PathDotNet(
             self._app, self.api.Path.Create(layout, layer, net, width, end_cap1, end_cap2, corner_style, points)
         )
@@ -847,11 +856,15 @@ class PathDotNet(PrimitiveDotNet):
     @property
     def center_line(self):
         """:class:`PolygonData <ansys.edb.geometry.PolygonData>`: Center line for this Path."""
-        return self.prim_obj.GetCenterLine()
+        edb_center_line = self.prim_obj.GetCenterLine()
+        return [[pt.X.ToDouble(), pt.Y.ToDouble()] for pt in list(edb_center_line.Points)]
 
     @center_line.setter
-    def center_line(self, center_line):
-        self.prim_obj.SetCenterLineMessage(center_line)
+    def center_line(self, value):
+        if isinstance(value, list):
+            points = [self._pedb.point_data(i[0], i[1]) for i in value]
+            polygon_data = self._edb.geometry.polygon_data.dotnetobj(convert_py_list_to_net_list(points), False)
+            self.prim_obj.SetCenterLine(polygon_data)
 
     @property
     def end_cap_style(self):

pyedb/dotnet/edb_core/edb_data/control_file.py

@@ -23,24 +23,14 @@
 import copy
 import os
 import re
+import subprocess
 import sys
 
 from pyedb.edb_logger import pyedb_logger
-from pyedb.generic.general_methods import (
-    ET,
-    env_path,
-    env_value,
-    is_ironpython,
-    is_linux,
-)
+from pyedb.generic.general_methods import ET, env_path, env_value, is_linux
 from pyedb.misc.aedtlib_personalib_install import write_pretty_xml
 from pyedb.misc.misc import list_installed_ansysem
 
-if is_linux and is_ironpython:
-    import subprocessdotnet as subprocess
-else:
-    import subprocess
-
 
 def convert_technology_file(tech_file, edbversion=None, control_file=None):
     """Convert a technology file to edb control file (xml).

pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -25,12 +25,12 @@ import math
 import re
 import warnings
 
-from pyedb.dotnet.clr_module import String, _clr
+from pyedb.dotnet.clr_module import String
 from pyedb.dotnet.edb_core.cell.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.generic.general_methods import generate_unique_name, is_ironpython
+from pyedb.generic.general_methods import generate_unique_name
 from pyedb.modeler.geometry_operators import GeometryOperators
 
 
@@ -1403,17 +1403,12 @@ class EDBPadstackInstance(Primitive):
         layer = self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer)
         val = self._pedb.edb_value(0)
         offset = self._pedb.edb_value(0.0)
-        if is_ironpython:  # pragma: no cover
-            diameter = _clr.StrongBox[type(val)]()
-            drill_to_layer = _clr.StrongBox[self._pedb.edb_api.Cell.ILayerReadOnly]()
-            flag = self._edb_padstackinstance.GetBackDrillParametersLayerValue(drill_to_layer, offset, diameter, False)
-        else:
-            (
-                flag,
-                drill_to_layer,
-                offset,
-                diameter,
-            ) = self._edb_padstackinstance.GetBackDrillParametersLayerValue(layer, offset, val, False)
+        (
+            flag,
+            drill_to_layer,
+            offset,
+            diameter,
+        ) = self._edb_padstackinstance.GetBackDrillParametersLayerValue(layer, offset, val, False)
         if flag:
             if offset.ToDouble():
                 return drill_to_layer.GetName(), diameter.ToString(), offset.ToString()
@@ -1461,17 +1456,12 @@ class EDBPadstackInstance(Primitive):
         layer = self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer)
         val = self._pedb.edb_value(0)
         offset = self._pedb.edb_value(0.0)
-        if is_ironpython:  # pragma: no cover
-            diameter = _clr.StrongBox[type(val)]()
-            drill_to_layer = _clr.StrongBox[self._pedb.edb_api.Cell.ILayerReadOnly]()
-            flag = self._edb_padstackinstance.GetBackDrillParametersLayerValue(drill_to_layer, offset, diameter, True)
-        else:
-            (
-                flag,
-                drill_to_layer,
-                offset,
-                diameter,
-            ) = self._edb_padstackinstance.GetBackDrillParametersLayerValue(layer, offset, val, True)
+        (
+            flag,
+            drill_to_layer,
+            offset,
+            diameter,
+        ) = self._edb_padstackinstance.GetBackDrillParametersLayerValue(layer, offset, val, True)
         if flag:
             if offset.ToDouble():
                 return drill_to_layer.GetName(), diameter.ToString(), offset.ToString()
@@ -1503,9 +1493,9 @@ class EDBPadstackInstance(Primitive):
         val = self._pedb.edb_value(drill_diameter)
         offset = self._pedb.edb_value(offset)
         if offset.ToDouble():
-            return self._edb_padstackinstance.SetBackDrillParameters(layer, offset, val, True)
+            return self._edb_object.SetBackDrillParameters(layer, offset, val, True)
         else:
-            return self._edb_padstackinstance.SetBackDrillParameters(layer, val, True)
+            return self._edb_object.SetBackDrillParameters(layer, val, True)
 
     @property
     def start_layer(self):
@@ -1517,7 +1507,7 @@ class EDBPadstackInstance(Primitive):
             Name of the starting layer.
         """
         layer = self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer)
-        _, start_layer, stop_layer = self._edb_padstackinstance.GetLayerRange()
+        _, start_layer, stop_layer = self._edb_object.GetLayerRange()
 
         if start_layer:
             return start_layer.GetName()
@@ -1678,11 +1668,9 @@ class EDBPadstackInstance(Primitive):
     def name(self):
         """Padstack Instance Name. If it is a pin, the syntax will be like in AEDT ComponentName-PinName."""
         if self.is_pin:
-            comp_name = self._edb_padstackinstance.GetComponent().GetName()
-            pin_name = self._edb_padstackinstance.GetName()
-            return "-".join([comp_name, pin_name])
+            return self.aedt_name
         else:
-            return self._edb_padstackinstance.GetName()
+            return self.component_pin
 
     @name.setter
     def name(self, value):
@@ -1725,6 +1713,12 @@ class EDBPadstackInstance(Primitive):
     @property
     def pin_number(self):
         """Get pin number."""
+        warnings.warn("`pin_number` is deprecated. Use `component_pin` method instead.", DeprecationWarning)
+        return self.component_pin
+
+    @property
+    def component_pin(self):
+        """Get component pin."""
         return self._edb_padstackinstance.GetName()
 
     @property
@@ -1747,12 +1741,9 @@ class EDBPadstackInstance(Primitive):
         >>> edbapp.padstacks.instances[111].get_aedt_pin_name()
 
         """
-        if is_ironpython:
-            name = _clr.Reference[String]()
-            self._edb_padstackinstance.GetProductProperty(self._pedb.edb_api.ProductId.Designer, 11, name)
-        else:
-            val = String("")
-            _, name = self._edb_padstackinstance.GetProductProperty(self._pedb.edb_api.ProductId.Designer, 11, val)
+
+        val = String("")
+        _, name = self._edb_padstackinstance.GetProductProperty(self._pedb.edb_api.ProductId.Designer, 11, val)
         name = str(name).strip("'")
         return name
 

pyedb/dotnet/edb_core/edb_data/ports.py

@@ -198,24 +198,6 @@ class ExcitationSources(Terminal):
     def __init__(self, pedb, edb_terminal):
         Terminal.__init__(self, pedb, edb_terminal)
 
-    @property
-    def magnitude(self):
-        """Get the magnitude of the source."""
-        return self._edb_object.GetSourceAmplitude().ToDouble()
-
-    @magnitude.setter
-    def magnitude(self, value):
-        self._edb_object.SetSourceAmplitude(self._edb.utility.value(value))
-
-    @property
-    def phase(self):
-        """Get the phase of the source."""
-        return self._edb_object.GetSourcePhase().ToDouble()
-
-    @phase.setter
-    def phase(self, value):
-        self._edb_object.SetSourcePhase(self._edb.utility.value(value))
-
 
 class BundleWavePort(BundleTerminal):
     """Manages bundle wave port properties.

pyedb/dotnet/edb_core/edb_data/primitives_data.py

@@ -631,7 +631,7 @@ class EdbPath(EDBPrimitives, PathDotNet):
         float
             Path length in meters.
         """
-        center_line_arcs = list(self.center_line.GetArcData())
+        center_line_arcs = list(self.api_object.GetCenterLine().GetArcData())
         path_length = 0.0
         for arc in center_line_arcs:
             path_length += arc.GetLength()