pyedb 0.36.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

pyedb/__init__.py

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

pyedb/configuration/cfg_common.py

@@ -22,7 +22,7 @@
 
 
 class CfgBase:
-    protected_attributes = []
+    protected_attributes = ["pedb", "pyedb_obj", "api"]
 
     def get_attributes(self, exclude=None):
         attrs = {i: j for i, j in self.__dict__.items() if i not in self.protected_attributes}

pyedb/configuration/cfg_components.py

@@ -19,244 +19,272 @@
 # 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 os
 
 from pyedb.configuration.cfg_common import CfgBase
 from pyedb.dotnet.edb_core.general import pascal_to_snake, snake_to_pascal
 
 
 class CfgComponent(CfgBase):
-    def __init__(self, pedb, pedb_object, **kwargs):
-        self._pedb = pedb
-        self._pyedb_obj = pedb_object
+    class Common:
+        @property
+        def pyedb_obj(self):
+            return self.parent.pyedb_obj
 
-        self.enabled = kwargs.get("enabled", None)
-        self.reference_designator = kwargs.get("reference_designator", None)
-        self.definition = kwargs.get("definition", None)
-        self.type = kwargs["part_type"].lower() if kwargs.get("part_type") else None
-        self.placement_layer = kwargs.get("placement_layer", None)
-        self.pins = kwargs.get("pins", [])
+        def __init__(self, parent):
+            self.parent = parent
+            self.pedb = parent.pedb
 
-        self.port_properties = kwargs.get("port_properties", {})
-        self.solder_ball_properties = kwargs.get("solder_ball_properties", {})
-        self.ic_die_properties = kwargs.get("ic_die_properties", {})
-        self.pin_pair_model = kwargs.get("pin_pair_model", [])
-        self.spice_model = kwargs.get("spice_model", {})
-        self.s_parameter_model = kwargs.get("s_parameter_model", {})
-        self.netlist_model = kwargs.get("netlist_model", {})
+        def retrieve_model_properties_from_edb(self):
+            c_p = self.pyedb_obj.component_property
+            model = c_p.GetModel().Clone()
 
-    def retrieve_model_properties_from_edb(self):
-        c_p = self._pyedb_obj.component_property
-        model = c_p.GetModel().Clone()
+            if model.GetModelType().ToString() == "NetlistModel":
+                self.parent.netlist_model["netlist"] = model.GetNetlist()
+            elif model.GetModelType().ToString() == "PinPairModel":
+                temp = {}
+                for i in model.PinPairs:
+                    temp["first_pin"] = i.FirstPin
+                    temp["second_pin"] = i.SecondPin
+                    rlc = model.GetPinPairRlc(i)
+                    temp["is_parallel"] = rlc.IsParallel
+                    temp["resistance"] = rlc.R.ToString()
+                    temp["resistance_enabled"] = rlc.REnabled
+                    temp["inductance"] = rlc.L.ToString()
+                    temp["inductance_enabled"] = rlc.LEnabled
+                    temp["capacitance"] = rlc.C.ToString()
+                    temp["capacitance_enabled"] = rlc.CEnabled
+                    self.parent.pin_pair_model.append(temp)
+            elif model.GetModelType().ToString() == "SParameterModel":
+                self.parent.s_parameter_model["reference_net"] = model.GetReferenceNet()
+                self.parent.s_parameter_model["model_name"] = model.GetComponentModelName()
+            elif model.GetModelType().ToString() == "SPICEModel":
+                self.parent.spice_model["model_name"] = model.GetModelName()
+                self.parent.spice_model["model_path"] = model.GetModelPath()
+                self.parent.spice_model["sub_circuit"] = model.GetSubCkt()
+                self.parent.spice_model["terminal_pairs"] = [
+                    [i, j] for i, j in dict(model.GetTerminalPinPairs()).items()
+                ]
 
-        if model.GetModelType().ToString() == "NetlistModel":
-            self.netlist_model["netlist"] = model.GetNetlist()
-        elif model.GetModelType().ToString() == "PinPairModel":
-            temp = {}
-            for i in model.PinPairs:
-                temp["first_pin"] = i.FirstPin
-                temp["second_pin"] = i.SecondPin
-                rlc = model.GetPinPairRlc(i)
-                temp["is_parallel"] = rlc.IsParallel
-                temp["resistance"] = rlc.R.ToString()
-                temp["resistance_enabled"] = rlc.REnabled
-                temp["inductance"] = rlc.L.ToString()
-                temp["inductance_enabled"] = rlc.LEnabled
-                temp["capacitance"] = rlc.C.ToString()
-                temp["capacitance_enabled"] = rlc.CEnabled
-                self.pin_pair_model.append(temp)
-        elif model.GetModelType().ToString() == "SParameterModel":
-            self.s_parameter_model["reference_net"] = model.GetReferenceNet()
-            self.s_parameter_model["model_name"] = model.GetComponentModelName()
-        elif model.GetModelType().ToString() == "SPICEModel":
-            self.spice_model["model_name"] = model.GetModelName()
-            self.spice_model["model_path"] = model.GetModelPath()
-            self.spice_model["sub_circuit"] = model.GetSubCkt()
-            self.spice_model["terminal_pairs"] = [[i, j] for i, j in dict(model.GetTerminalPinPairs()).items()]
-
-    def _set_model_properties_to_edb(self):
-        c_p = self._pyedb_obj.component_property
-        if self.netlist_model:
-            m = self._pedb._edb.Cell.Hierarchy.SParameterModel()
-            m.SetNetlist(self.netlist_model["netlist"])
-            c_p.SetModel(m)
-            self.component_property = c_p
-        elif self.pin_pair_model:
-            m = self._pedb._edb.Cell.Hierarchy.PinPairModel()
-            for i in self.pin_pair_model:
-                p = self._pedb._edb.Utility.PinPair(str(i["first_pin"]), str(i["second_pin"]))
-                rlc = self._pedb._edb.Utility.Rlc(
-                    self._pedb.edb_value(i["resistance"]),
-                    i["resistance_enabled"],
-                    self._pedb.edb_value(i["inductance"]),
-                    i["inductance_enabled"],
-                    self._pedb.edb_value(i["capacitance"]),
-                    i["capacitance_enabled"],
-                    i["is_parallel"],
+        def _set_model_properties_to_edb(self):
+            c_p = self.pyedb_obj.component_property
+            if self.parent.netlist_model:
+                m = self.pedb._edb.Cell.Hierarchy.SParameterModel()
+                m.SetNetlist(self.parent.netlist_model["netlist"])
+                c_p.SetModel(m)
+                self.component_property = c_p
+            elif self.parent.pin_pair_model:
+                m = self.pedb._edb.Cell.Hierarchy.PinPairModel()
+                for i in self.parent.pin_pair_model:
+                    p = self.pedb._edb.Utility.PinPair(str(i["first_pin"]), str(i["second_pin"]))
+                    rlc = self.pedb._edb.Utility.Rlc(
+                        self.pedb.edb_value(i["resistance"]),
+                        i["resistance_enabled"],
+                        self.pedb.edb_value(i["inductance"]),
+                        i["inductance_enabled"],
+                        self.pedb.edb_value(i["capacitance"]),
+                        i["capacitance_enabled"],
+                        i["is_parallel"],
+                    )
+                    m.SetPinPairRlc(p, rlc)
+                c_p.SetModel(m)
+                self.pyedb_obj.component_property = c_p
+            elif self.parent.s_parameter_model:
+                m = self.pedb._edb.Cell.Hierarchy.SParameterModel()
+                m.SetComponentModelName(self.parent.s_parameter_model["model_name"])
+                m.SetReferenceNet(self.parent.s_parameter_model["reference_net"])
+                c_p.SetModel(m)
+                self.component_property = c_p
+            elif self.parent.spice_model:
+                self.pyedb_obj.assign_spice_model(
+                    self.parent.spice_model["model_path"],
+                    self.parent.spice_model["model_name"],
+                    self.parent.spice_model["sub_circuit"],
+                    self.parent.spice_model["terminal_pairs"],
                 )
-                m.SetPinPairRlc(p, rlc)
-            c_p.SetModel(m)
-            self._pyedb_obj.component_property = c_p
-        elif self.s_parameter_model:
-            m = self._pedb._edb.Cell.Hierarchy.SParameterModel()
-            m.SetComponentModelName(self.s_parameter_model["model_name"])
-            m.SetReferenceNet(self.s_parameter_model["reference_net"])
-            c_p.SetModel(m)
-            self.component_property = c_p
-        elif self.spice_model:
-            self._pyedb_obj.assign_spice_model(
-                self.spice_model["model_path"],
-                self.spice_model["model_name"],
-                self.spice_model["sub_circuit"],
-                self.spice_model["terminal_pairs"],
-            )
 
-    def _retrieve_ic_die_properties_from_edb(self):
-        temp = dict()
-        cp = self._pyedb_obj.component_property
-        ic_die_prop = cp.GetDieProperty().Clone()
-        die_type = pascal_to_snake(ic_die_prop.GetType().ToString())
-        temp["type"] = die_type
-        if not die_type == "no_die":
-            temp["orientation"] = pascal_to_snake(ic_die_prop.GetOrientation().ToString())
-            if die_type == "wire_bond":
-                temp["height"] = ic_die_prop.GetHeightValue().ToString()
-        self.ic_die_properties = temp
+        def _retrieve_ic_die_properties_from_edb(self):
+            temp = dict()
+            cp = self.pyedb_obj.component_property
+            ic_die_prop = cp.GetDieProperty().Clone()
+            die_type = pascal_to_snake(ic_die_prop.GetType().ToString())
+            temp["type"] = die_type
+            if not die_type == "no_die":
+                temp["orientation"] = pascal_to_snake(ic_die_prop.GetOrientation().ToString())
+                if die_type == "wire_bond":
+                    temp["height"] = ic_die_prop.GetHeightValue().ToString()
+            self.parent.ic_die_properties = temp
 
-    def _set_ic_die_properties_to_edb(self):
-        cp = self._pyedb_obj.component_property
-        ic_die_prop = cp.GetDieProperty().Clone()
-        die_type = self.ic_die_properties.get("type")
-        ic_die_prop.SetType(getattr(self._pedb._edb.Definition.DieType, snake_to_pascal(die_type)))
-        if not die_type == "no_die":
-            orientation = self.ic_die_properties.get("orientation")
-            if orientation:
-                ic_die_prop.SetOrientation(
-                    getattr(self._pedb._edb.Definition.DieOrientation, snake_to_pascal(orientation))
-                )
-            if die_type == "wire_bond":
-                height = self.ic_die_properties.get("height")
-                if height:
-                    ic_die_prop.SetHeight(self._pedb.edb_value(height))
-        cp.SetDieProperty(ic_die_prop)
-        self._pyedb_obj.component_property = cp
+        def _set_ic_die_properties_to_edb(self):
+            cp = self.pyedb_obj.component_property
+            ic_die_prop = cp.GetDieProperty().Clone()
+            die_type = self.parent.ic_die_properties.get("type")
+            ic_die_prop.SetType(getattr(self.pedb._edb.Definition.DieType, snake_to_pascal(die_type)))
+            if not die_type == "no_die":
+                orientation = self.parent.ic_die_properties.get("orientation")
+                if orientation:
+                    ic_die_prop.SetOrientation(
+                        getattr(self.pedb._edb.Definition.DieOrientation, snake_to_pascal(orientation))
+                    )
+                if die_type == "wire_bond":
+                    height = self.parent.ic_die_properties.get("height")
+                    if height:
+                        ic_die_prop.SetHeight(self.pedb.edb_value(height))
+            cp.SetDieProperty(ic_die_prop)
+            self.pyedb_obj.component_property = cp
 
-    def _retrieve_solder_ball_properties_from_edb(self):
-        temp = dict()
-        cp = self._pyedb_obj.component_property
-        solder_ball_prop = cp.GetSolderBallProperty().Clone()
-        _, diam, mid_diam = solder_ball_prop.GetDiameterValue()
-        height = solder_ball_prop.GetHeightValue().ToString()
-        shape = solder_ball_prop.GetShape().ToString()
-        uses_solder_ball = solder_ball_prop.UsesSolderball()
-        temp["uses_solder_ball"] = uses_solder_ball
-        temp["shape"] = pascal_to_snake(shape)
-        temp["diameter"] = diam.ToString()
-        temp["mid_diameter"] = mid_diam.ToString()
-        temp["height"] = height
-        self.solder_ball_properties = temp
+        def _retrieve_solder_ball_properties_from_edb(self):
+            temp = dict()
+            cp = self.pyedb_obj.component_property
+            solder_ball_prop = cp.GetSolderBallProperty().Clone()
+            _, diam, mid_diam = solder_ball_prop.GetDiameterValue()
+            height = solder_ball_prop.GetHeightValue().ToString()
+            shape = solder_ball_prop.GetShape().ToString()
+            material = solder_ball_prop.GetMaterialName()
+            uses_solder_ball = solder_ball_prop.UsesSolderball()
 
-    def _set_solder_ball_properties_to_edb(self):
-        cp = self._pyedb_obj.component_property
-        solder_ball_prop = cp.GetSolderBallProperty().Clone()
-        shape = self.solder_ball_properties.get("shape")
-        if shape:
-            solder_ball_prop.SetShape(getattr(self._pedb._edb.Definition.SolderballShape, snake_to_pascal(shape)))
-        else:
-            return
+            temp["uses_solder_ball"] = uses_solder_ball
+            temp["shape"] = pascal_to_snake(shape)
+            temp["diameter"] = diam.ToString()
+            temp["mid_diameter"] = mid_diam.ToString()
+            temp["height"] = height
+            temp["material"] = material
+            self.parent.solder_ball_properties = temp
 
-        if shape == "cylinder":
-            diameter = self.solder_ball_properties["diameter"]
-            solder_ball_prop.SetDiameter(self._pedb.edb_value(diameter), self._pedb.edb_value(diameter))
-        elif shape == "spheroid":
-            diameter = self.solder_ball_properties["diameter"]
-            mid_diameter = self.solder_ball_properties["mid_diameter"]
-            solder_ball_prop.SetDiameter(self._pedb.edb_value(diameter), self._pedb.edb_value(mid_diameter))
-        else:
-            raise ValueError("Solderball shape must be either cylinder or spheroid")
-        solder_ball_prop.SetHeight(self._pedb.edb_value(self.solder_ball_properties["height"]))
-        cp.SetSolderBallProperty(solder_ball_prop)
-        self._pyedb_obj.component_property = cp
+        def _set_solder_ball_properties_to_edb(self):
+            cp = self.pyedb_obj.component_property
+            solder_ball_prop = cp.GetSolderBallProperty().Clone()
+            shape = self.parent.solder_ball_properties.get("shape")
+            if shape:
+                solder_ball_prop.SetShape(getattr(self.pedb._edb.Definition.SolderballShape, snake_to_pascal(shape)))
+            else:
+                return
 
-    def _retrieve_port_properties_from_edb(self):
-        temp = dict()
-        cp = self._pyedb_obj.component_property
-        c_type = self.type.lower()
-        if c_type not in ["ic", "io", "other"]:
-            return
-        else:
+            if shape == "cylinder":
+                diameter = self.parent.solder_ball_properties["diameter"]
+                solder_ball_prop.SetDiameter(self.pedb.edb_value(diameter), self.pedb.edb_value(diameter))
+            elif shape == "spheroid":
+                diameter = self.parent.solder_ball_properties["diameter"]
+                mid_diameter = self.parent.solder_ball_properties["mid_diameter"]
+                solder_ball_prop.SetDiameter(self.pedb.edb_value(diameter), self.pedb.edb_value(mid_diameter))
+            else:
+                raise ValueError("Solderball shape must be either cylinder or spheroid")
+            solder_ball_prop.SetHeight(self.pedb.edb_value(self.parent.solder_ball_properties["height"]))
+            solder_ball_prop.SetMaterialName(self.parent.solder_ball_properties.get("material", "solder"))
+            cp.SetSolderBallProperty(solder_ball_prop)
+            self.pyedb_obj.component_property = cp
+
+        def _retrieve_port_properties_from_edb(self):
+            temp = dict()
+            cp = self.pyedb_obj.component_property
+            c_type = self.parent.type.lower()
+            if c_type not in ["ic", "io", "other"]:
+                return
+            else:
+                port_prop = cp.GetPortProperty().Clone()
+                reference_height = port_prop.GetReferenceHeightValue().ToString()
+                reference_size_auto = port_prop.GetReferenceSizeAuto()
+                _, reference_size_x, reference_size_y = port_prop.GetReferenceSize()
+                temp["reference_height"] = reference_height
+                temp["reference_size_auto"] = reference_size_auto
+                temp["reference_size_x"] = str(reference_size_x)
+                temp["reference_size_y"] = str(reference_size_y)
+                self.parent.port_properties = temp
+
+        def _set_port_properties_to_edb(self):
+            cp = self.pyedb_obj.component_property
             port_prop = cp.GetPortProperty().Clone()
-            reference_height = port_prop.GetReferenceHeightValue().ToString()
-            reference_size_auto = port_prop.GetReferenceSizeAuto()
-            _, reference_size_x, reference_size_y = port_prop.GetReferenceSize()
-            temp["reference_height"] = reference_height
-            temp["reference_size_auto"] = reference_size_auto
-            temp["reference_size_x"] = str(reference_size_x)
-            temp["reference_size_y"] = str(reference_size_y)
-            self.port_properties = temp
+            height = self.parent.port_properties.get("reference_height")
+            if height:
+                port_prop.SetReferenceHeight(self.pedb.edb_value(height))
+            reference_size_auto = self.parent.port_properties.get("reference_size_auto")
+            if reference_size_auto is not None:
+                port_prop.SetReferenceSizeAuto(reference_size_auto)
+            reference_size_x = self.parent.port_properties.get("reference_size_x", 0)
+            reference_size_y = self.parent.port_properties.get("reference_size_y", 0)
+            port_prop.SetReferenceSize(self.pedb.edb_value(reference_size_x), self.pedb.edb_value(reference_size_y))
+            cp.SetPortProperty(port_prop)
+            self.pyedb_obj.component_property = cp
 
-    def _set_port_properties_to_edb(self):
-        cp = self._pyedb_obj.component_property
-        port_prop = cp.GetPortProperty().Clone()
-        height = self.port_properties.get("reference_height")
-        if height:
-            port_prop.SetReferenceHeight(self._pedb.edb_value(height))
-        reference_size_auto = self.port_properties.get("reference_size_auto")
-        if reference_size_auto is not None:
-            port_prop.SetReferenceSizeAuto(reference_size_auto)
-        reference_size_x = self.port_properties.get("reference_size_x", 0)
-        reference_size_y = self.port_properties.get("reference_size_y", 0)
-        port_prop.SetReferenceSize(self._pedb.edb_value(reference_size_x), self._pedb.edb_value(reference_size_y))
-        cp.SetPortProperty(port_prop)
-        self._pyedb_obj.component_property = cp
+        def set_parameters_to_edb(self):
+            if self.parent.type:
+                self.pyedb_obj.type = self.parent.type
+            if self.parent.enabled:
+                self.pyedb_obj.enabled = self.parent.enabled
 
-    def set_parameters_to_edb(self):
-        if self.type:
-            self._pyedb_obj.type = self.type
-        if self.enabled:
-            self._pyedb_obj.enabled = self.enabled
+            self._set_model_properties_to_edb()
+            if self.pyedb_obj.type.lower() == "ic":
+                self._set_ic_die_properties_to_edb()
+                self._set_port_properties_to_edb()
+            elif self.pyedb_obj.type.lower() in ["io", "other"]:
+                self._set_solder_ball_properties_to_edb()
+                self._set_port_properties_to_edb()
 
-        self._set_model_properties_to_edb()
-        if self._pyedb_obj.type.lower() == "ic":
-            self._set_ic_die_properties_to_edb()
-            self._set_port_properties_to_edb()
-        elif self._pyedb_obj.type.lower() in ["io", "other"]:
-            self._set_solder_ball_properties_to_edb()
-            self._set_port_properties_to_edb()
+        def retrieve_parameters_from_edb(self):
+            self.parent.type = self.pyedb_obj.type
+            self.parent.definition = self.pyedb_obj.part_name
+            self.parent.reference_designator = self.pyedb_obj.name
+            self.retrieve_model_properties_from_edb()
+            if self.pyedb_obj.type.lower() == "ic":
+                self._retrieve_ic_die_properties_from_edb()
+                self._retrieve_port_properties_from_edb()
+            elif self.pyedb_obj.type.lower() in ["io", "other"]:
+                self._retrieve_solder_ball_properties_from_edb()
+                self._retrieve_port_properties_from_edb()
 
-    def retrieve_parameters_from_edb(self):
-        self.type = self._pyedb_obj.type
-        self.definition = self._pyedb_obj.part_name
-        self.reference_designator = self._pyedb_obj.name
-        self.retrieve_model_properties_from_edb()
-        if self._pyedb_obj.type.lower() == "ic":
-            self._retrieve_ic_die_properties_from_edb()
-            self._retrieve_port_properties_from_edb()
-        elif self._pyedb_obj.type.lower() in ["io", "other"]:
-            self._retrieve_solder_ball_properties_from_edb()
-            self._retrieve_port_properties_from_edb()
+    class Grpc(Common):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+    def __init__(self, pedb, pedb_object, **kwargs):
+        self.pedb = pedb
+        self.pyedb_obj = pedb_object
+        if os.environ["PYEDB_USE_DOTNET"] == "0":
+            self.api = self.Grpc(self)
+        else:
+            self.api = self.DotNet(self)
+
+        self.enabled = kwargs.get("enabled", None)
+        self.reference_designator = kwargs.get("reference_designator", None)
+        self.definition = kwargs.get("definition", None)
+        self.type = kwargs["part_type"].lower() if kwargs.get("part_type") else None
+        self.placement_layer = kwargs.get("placement_layer", None)
+        self.pins = kwargs.get("pins", [])
+
+        self.port_properties = kwargs.get("port_properties", {})
+        self.solder_ball_properties = kwargs.get("solder_ball_properties", {})
+        self.ic_die_properties = kwargs.get("ic_die_properties", {})
+        self.pin_pair_model = kwargs.get("pin_pair_model", [])
+        self.spice_model = kwargs.get("spice_model", {})
+        self.s_parameter_model = kwargs.get("s_parameter_model", {})
+        self.netlist_model = kwargs.get("netlist_model", {})
 
 
 class CfgComponents:
     def __init__(self, pedb, components_data):
-        self._pedb = pedb
+        self.pedb = pedb
         self.components = []
 
         if components_data:
             for comp in components_data:
-                obj = self._pedb.layout.find_component_by_name(comp["reference_designator"])
-                self.components.append(CfgComponent(self._pedb, obj, **comp))
+                obj = self.pedb.layout.find_component_by_name(comp["reference_designator"])
+                self.components.append(CfgComponent(self.pedb, obj, **comp))
 
     def clean(self):
         self.components = []
 
     def apply(self):
         for comp in self.components:
-            comp.set_parameters_to_edb()
+            comp.api.set_parameters_to_edb()
 
     def retrieve_parameters_from_edb(self):
         self.clean()
-        comps_in_db = self._pedb.components
+        comps_in_db = self.pedb.components
         for _, comp in comps_in_db.instances.items():
-            cfg_comp = CfgComponent(self._pedb, comp)
-            cfg_comp.retrieve_parameters_from_edb()
+            cfg_comp = CfgComponent(self.pedb, comp)
+            cfg_comp.api.retrieve_parameters_from_edb()
             self.components.append(cfg_comp)

pyedb/configuration/cfg_data.py

@@ -31,7 +31,7 @@ from pyedb.configuration.cfg_operations import CfgOperations
 from pyedb.configuration.cfg_package_definition import CfgPackageDefinitions
 from pyedb.configuration.cfg_padstacks import CfgPadstacks
 from pyedb.configuration.cfg_pin_groups import CfgPinGroups
-from pyedb.configuration.cfg_ports_sources import CfgPorts, CfgSources
+from pyedb.configuration.cfg_ports_sources import CfgPorts, CfgProbes, CfgSources
 from pyedb.configuration.cfg_s_parameter_models import CfgSParameters
 from pyedb.configuration.cfg_setup import CfgSetups
 from pyedb.configuration.cfg_spice_models import CfgSpiceModel
@@ -78,3 +78,5 @@ class CfgData(object):
         self.modeler = CfgModeler(self._pedb, data=kwargs.get("modeler", {}))
 
         self.variables = CfgVariables(self._pedb, data=kwargs.get("variables", []))
+
+        self.probes = CfgProbes(self._pedb, data=kwargs.get("probes", []))

pyedb/configuration/cfg_modeler.py

@@ -90,8 +90,8 @@ class CfgModeler:
                 pdef = self._pedb._edb.Definition.PadstackDef.Create(self._pedb.active_db, p.name)
                 pdef.SetData(pdata)
                 pdef = EDBPadstack(pdef, self._pedb.padstacks)
-                p._pyedb_obj = pdef
-                p.set_parameters_to_edb()
+                p.pyedb_obj = pdef
+                p.api.set_parameters_to_edb()
 
         if self.padstack_instances:
             for p in self.padstack_instances:
@@ -101,8 +101,8 @@ class CfgModeler:
                     position=p.position,
                     definition_name=p.definition,
                 )
-                p._pyedb_obj = p_inst
-                p.set_parameters_to_edb()
+                p.pyedb_obj = p_inst
+                p.api.set_parameters_to_edb()
 
         if self.planes:
             for p in self.planes:
@@ -136,5 +136,5 @@ class CfgModeler:
                     placement_layer=c.placement_layer,
                     component_part_name=c.definition,
                 )
-                c._pyedb_obj = obj
-                c.set_parameters_to_edb()
+                c.pyedb_obj = obj
+                c.api.set_parameters_to_edb()