pyedb 0.27.0__tar.gz → 0.29.0__tar.gz

{pyedb-0.27.0 → pyedb-0.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyedb
-Version: 0.27.0
+Version: 0.29.0
 Summary: Higher-Level Pythonic Ansys Electronics Data Base
 Author-email: "ANSYS, Inc." <pyansys.core@ansys.com>
 Maintainer-email: PyEDB developers <simon.vandenbrouck@ansys.com>
@@ -19,9 +19,9 @@ Requires-Dist: cffi>=1.16.0,<1.18; platform_system=='Linux'
 Requires-Dist: pywin32 >= 303;platform_system=='Windows'
 Requires-Dist: ansys-pythonnet >= 3.1.0rc3
 Requires-Dist: dotnetcore2 ==3.1.23;platform_system=='Linux'
-Requires-Dist: numpy>=1.20.0,<2.2
+Requires-Dist: numpy>=1.20.0,<2
 Requires-Dist: pandas>=1.1.0,<2.3
-Requires-Dist: pydantic>=2.6.4,<2.9
+Requires-Dist: pydantic>=2.6.4,<2.10
 Requires-Dist: Rtree >= 1.2.0
 Requires-Dist: toml == 0.10.2
 Requires-Dist: scikit-rf
@@ -37,8 +37,8 @@ Requires-Dist: numpydoc>=1.5.0,<1.9 ; extra == "doc"
 Requires-Dist: pypandoc>=1.10.0,<1.14 ; extra == "doc"
 Requires-Dist: recommonmark ; extra == "doc"
 Requires-Dist: Sphinx>=7.1.0,<8.1 ; extra == "doc"
-Requires-Dist: sphinx-autobuild==2024.2.4 ; extra == "doc" and ( python_version == '3.8')
-Requires-Dist: sphinx-autobuild==2024.2.4 ; extra == "doc" and ( python_version > '3.8')
+Requires-Dist: sphinx-autobuild==2021.3.14 ; extra == "doc" and ( python_version == '3.8')
+Requires-Dist: sphinx-autobuild==2024.9.19 ; extra == "doc" and ( python_version > '3.8')
 Requires-Dist: sphinx-copybutton>=0.5.0,<0.6 ; extra == "doc"
 Requires-Dist: sphinx-gallery>=0.14.0,<0.18 ; extra == "doc"
 Requires-Dist: sphinx_design>=0.4.0,<0.7 ; extra == "doc"

{pyedb-0.27.0 → pyedb-0.29.0}/pyproject.toml

@@ -29,9 +29,9 @@ dependencies = [
     "pywin32 >= 303;platform_system=='Windows'",
     "ansys-pythonnet >= 3.1.0rc3",
     "dotnetcore2 ==3.1.23;platform_system=='Linux'",
-    "numpy>=1.20.0,<2.2",
+    "numpy>=1.20.0,<2",
     "pandas>=1.1.0,<2.3",
-    "pydantic>=2.6.4,<2.9",
+    "pydantic>=2.6.4,<2.10",
     "Rtree >= 1.2.0",
     "toml == 0.10.2",
     "scikit-rf"
@@ -60,8 +60,8 @@ doc = [
     # NOTE: Remove recommonmark once examples are reworked.
     "recommonmark",
     "Sphinx>=7.1.0,<8.1",
-    "sphinx-autobuild==2024.2.4; python_version == '3.8'",
-    "sphinx-autobuild==2024.2.4; python_version > '3.8'",
+    "sphinx-autobuild==2021.3.14; python_version == '3.8'",
+    "sphinx-autobuild==2024.9.19; python_version > '3.8'",
     "sphinx-copybutton>=0.5.0,<0.6",
     "sphinx-gallery>=0.14.0,<0.18",
     "sphinx_design>=0.4.0,<0.7",

{pyedb-0.27.0 → pyedb-0.29.0}/src/pyedb/__init__.py

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

pyedb-0.29.0/src/pyedb/configuration/cfg_boundaries.py

@@ -0,0 +1,95 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+from pyedb.configuration.cfg_common import CfgBase
+
+
+class CfgBoundaries(CfgBase):
+    def __init__(self, pedb, boundary_data):
+        self._pedb = pedb
+        self.open_region = boundary_data.get("open_region", None)
+        self.open_region_type = boundary_data.get("map_open_region_type", None)
+        self.pml_visible = boundary_data.get("pml_visible", None)
+        self.pml_operation_frequency = boundary_data.get("pml_operation_frequency", None)
+        self.pml_radiation_factor = boundary_data.get("pml_radiation_factor", None)
+        self.dielectric_extent_type = boundary_data.get("dielectric_extent_type", None)
+        # self.dielectric_base_polygon = self.**kwargs.get("dielectric_base_polygon", None)
+        self.horizontal_padding = boundary_data.get("horizontal_padding", None)
+        self.honor_primitives_on_dielectric_layers = boundary_data.get("honor_primitives_on_dielectric_layers", False)
+        self.air_box_extent_type = boundary_data.get("air_box_extent_type", None)
+        self.air_box_base_polygon = boundary_data.get("air_box_base_polygon", None)
+        self.air_box_truncate_model_ground_layers = boundary_data.get("air_box_truncate_model_ground_layers", None)
+        self.air_box_horizontal_padding = boundary_data.get("air_box_horizontal_padding", None)
+        self.air_box_positive_vertical_padding = boundary_data.get("air_box_positive_vertical_padding", None)
+        self.air_box_negative_vertical_padding = boundary_data.get("air_box_negative_vertical_padding", None)
+
+    def apply(self):
+        """Imports boundary information from JSON."""
+        if self.open_region is not None:
+            self._pedb.hfss.hfss_extent_info.use_open_region = self.open_region
+        if self.open_region_type:
+            self._pedb.hfss.hfss_extent_info.open_region_type = self.open_region_type.lower()
+        if self.pml_visible is not None:
+            self._pedb.hfss.hfss_extent_info.is_pml_visible = self.pml_visible
+        if self.pml_operation_frequency:
+            self._pedb.hfss.hfss_extent_info.operating_freq = self.pml_operation_frequency
+        if self.pml_radiation_factor:
+            self._pedb.hfss.hfss_extent_info.radiation_level = self.pml_radiation_factor
+        if self.dielectric_extent_type:
+            self._pedb.hfss.hfss_extent_info.extent_type = self.dielectric_extent_type.lower()
+        # if self.dielectric_base_polygon:
+        #    self._pedb.hfss.hfss_extent_info.dielectric_base_polygon = self.dielectric_base_polygon
+        if self.horizontal_padding:
+            self._pedb.hfss.hfss_extent_info.dielectric_extent_size = float(self.horizontal_padding)
+        if self.honor_primitives_on_dielectric_layers is not None:
+            self._pedb.hfss.hfss_extent_info.honor_user_dielectric = self.honor_primitives_on_dielectric_layers
+        if self.air_box_extent_type:
+            self._pedb.hfss.hfss_extent_info.extent_type = self.air_box_extent_type.lower()
+        if self.air_box_truncate_model_ground_layers is not None:
+            self._pedb.hfss.hfss_extent_info.truncate_air_box_at_ground = self.air_box_truncate_model_ground_layers
+        if self.air_box_horizontal_padding:
+            self._pedb.hfss.hfss_extent_info.air_box_horizontal_extent = float(self.air_box_horizontal_padding)
+        if self.air_box_positive_vertical_padding:
+            self._pedb.hfss.hfss_extent_info.air_box_positive_vertical_extent = float(
+                self.air_box_positive_vertical_padding
+            )
+        if self.air_box_negative_vertical_padding:
+            self._pedb.hfss.hfss_extent_info.air_box_negative_vertical_extent = float(
+                self.air_box_negative_vertical_padding
+            )
+
+    def get_data_from_db(self):
+        self.open_region = self._pedb.hfss.hfss_extent_info.use_open_region
+        self.open_region_type = self._pedb.hfss.hfss_extent_info.open_region_type
+        self.pml_visible = self._pedb.hfss.hfss_extent_info.is_pml_visible
+        self.pml_operation_frequency = self._pedb.hfss.hfss_extent_info.operating_freq.tostring
+        self.pml_radiation_factor = self._pedb.hfss.hfss_extent_info.radiation_level.tostring
+        self.dielectric_extent_type = self._pedb.hfss.hfss_extent_info.extent_type
+        # self.dielectric_base_polygon = self._pedb.hfss.hfss_extent_info.dielectric_base_polygon
+        self.horizontal_padding = self._pedb.hfss.hfss_extent_info.dielectric_extent_size
+        self.honor_primitives_on_dielectric_layers = self._pedb.hfss.hfss_extent_info.honor_user_dielectric
+        self.air_box_extent_type = self._pedb.hfss.hfss_extent_info.extent_type
+        self.air_box_truncate_model_ground_layers = self._pedb.hfss.hfss_extent_info.truncate_air_box_at_ground
+        self.air_box_horizontal_padding = self._pedb.hfss.hfss_extent_info.air_box_horizontal_extent
+        self.air_box_positive_vertical_padding = self._pedb.hfss.hfss_extent_info.air_box_positive_vertical_extent
+        self.air_box_negative_vertical_padding = self._pedb.hfss.hfss_extent_info.air_box_negative_vertical_extent
+        return self.get_attributes()

{pyedb-0.27.0 → pyedb-0.29.0}/src/pyedb/configuration/cfg_common.py

@@ -30,7 +30,7 @@ class CfgBase:
             exclude = exclude if isinstance(exclude, list) else [exclude]
             attrs = {i: j for i, j in attrs.items() if i not in exclude}
         attrs = {i: j for i, j in attrs.items() if not i.startswith("_")}
-        attrs = {i: j for i, j in attrs.items() if j is not None}
+        attrs = {i: j for i, j in attrs.items() if j not in [None, [], {}]}
         return attrs
 
     def set_attributes(self, pedb_object):

pyedb-0.29.0/src/pyedb/configuration/cfg_components.py

@@ -0,0 +1,101 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+from pyedb.configuration.cfg_common import CfgBase
+
+
+class CfgRlcModel(CfgBase):
+    def __init__(self, **kwargs):
+        self.resistance = kwargs.get("resistance", None)
+        self.inductance = kwargs.get("inductance", None)
+        self.capacitance = kwargs.get("capacitance", None)
+        self.type = kwargs.get("type", None)
+        self.p1 = kwargs.get("p1", None)
+        self.p2 = kwargs.get("p2", None)
+
+
+class CfgComponent(CfgBase):
+    def __init__(self, **kwargs):
+        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.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", None)
+        self.spice_model = kwargs.get("spice_model", None)
+        self.s_parameter_model = kwargs.get("s_parameter_model", None)
+
+
+class CfgComponents:
+    def __init__(self, pedb, components_data):
+        self._pedb = pedb
+        self.components = [CfgComponent(**comp) for comp in components_data]
+
+    def apply(self):
+        comps_in_db = self._pedb.components.components
+        for comp in self.components:
+            c_db = comps_in_db[comp.reference_designator]
+            if comp.definition:
+                c_db.definition = comp.definition
+            if comp.type:
+                c_db.type = comp.type
+            if comp.solder_ball_properties:
+                c_db.solder_ball_properties = comp.solder_ball_properties
+            if comp.port_properties:
+                c_db.port_properties = comp.port_properties
+            if comp.ic_die_properties:
+                c_db.set_ic_die_properties = comp.ic_die_properties
+            if comp.pin_pair_model:
+                c_db.model_properties = {"pin_pair_model": comp.pin_pair_model}
+            if comp.spice_model:
+                c_db.model_properties = {"spice_model": comp.spice_model}
+            if comp.s_parameter_model:
+                c_db.model_properties = {"s_parameter_model": comp.s_parameter_model}
+
+    def _load_data_from_db(self):
+        self.components = []
+        comps_in_db = self._pedb.components
+        for _, comp in comps_in_db.instances.items():
+            cfg_comp = CfgComponent(
+                enabled=comp.enabled,
+                reference_designator=comp.name,
+                part_type=comp.type,
+                pin_pair_model=comp.model_properties.get("pin_pair_model"),
+                spice_model=comp.model_properties.get("spice_model"),
+                s_parameter_model=comp.model_properties.get("s_parameter_model"),
+                definition=comp.component_def,
+                location=comp.location,
+                placement_layer=comp.placement_layer,
+                solder_ball_properties=comp.solder_ball_properties,
+                ic_die_properties=comp.ic_die_properties,
+                port_properties=comp.port_properties,
+            )
+            self.components.append(cfg_comp)
+
+    def get_data_from_db(self):
+        self._load_data_from_db()
+        data = []
+        for comp in self.components:
+            data.append(comp.get_attributes())
+        return data

{pyedb-0.27.0 → pyedb-0.29.0}/src/pyedb/configuration/cfg_data.py

@@ -30,7 +30,7 @@ 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_s_parameter_models import CfgSParameterModel
+from pyedb.configuration.cfg_s_parameter_models import CfgSParameters
 from pyedb.configuration.cfg_setup import CfgSetups
 from pyedb.configuration.cfg_spice_models import CfgSpiceModel
 from pyedb.configuration.cfg_stackup import CfgStackup
@@ -43,9 +43,7 @@ class CfgData(object):
         self._pedb = pedb
         self.general = CfgGeneral(self, kwargs.get("general", None))
 
-        self.boundaries = {}
-        if kwargs.get("boundaries", None):
-            self.boundaries = CfgBoundaries(self, kwargs.get("boundaries", None))
+        self.boundaries = CfgBoundaries(self._pedb, kwargs.get("boundaries", {}))
 
         self.nets = CfgNets(
             self, kwargs.get("nets", {}).get("signal_nets", []), kwargs.get("nets", {}).get("power_ground_nets", [])
@@ -53,7 +51,7 @@ class CfgData(object):
 
         self.components = CfgComponents(self._pedb, components_data=kwargs.get("components", []))
 
-        self.padstacks = CfgPadstacks(self, kwargs.get("padstacks", None))
+        self.padstacks = CfgPadstacks(self._pedb, kwargs.get("padstacks", None))
 
         self.pin_groups = CfgPinGroups(self._pedb, pingroup_data=kwargs.get("pin_groups", []))
 
@@ -65,10 +63,7 @@ class CfgData(object):
 
         self.stackup = CfgStackup(self._pedb, data=kwargs.get("stackup", {}))
 
-        self.s_parameters = [
-            CfgSParameterModel(self, self.general.s_parameter_library, sparam_model)
-            for sparam_model in kwargs.get("s_parameters", [])
-        ]
+        self.s_parameters = CfgSParameters(self._pedb, kwargs.get("s_parameters", []), self.general.s_parameter_library)
 
         self.spice_models = [
             CfgSpiceModel(self, self.general.spice_model_library, spice_model)

{pyedb-0.27.0 → pyedb-0.29.0}/src/pyedb/configuration/cfg_operations.py

@@ -53,19 +53,21 @@ class CfgCutout(CfgBase):
 
     def get_data_from_db(self):
         if "pyedb_cutout" in self._pedb.stackup.all_layers:
-            poly = self._pedb.layout.find_primitive(layer_name="pyedb_cutout")[0]
-            self.custom_extent = poly.polygon_data.points
+            polygons = self._pedb.layout.find_primitive(layer_name="pyedb_cutout")
+            if polygons:
+                poly = polygons[0]
+                self.custom_extent = poly.polygon_data.points
 
-            net_names = []
-            for name, obj in self._pedb.nets.nets.items():
-                if obj.primitives[0].layer.name == "pyedb_cutout":
-                    continue
-                if len(obj.primitives) > 0:
-                    net_names.append(name)
+                net_names = []
+                for name, obj in self._pedb.nets.nets.items():
+                    if obj.primitives[0].layer.name == "pyedb_cutout":
+                        continue
+                    if len(obj.primitives) > 0:
+                        net_names.append(name)
 
-            self.reference_list = []
-            self.signal_list = net_names
-        return self.export_properties()
+                self.reference_list = []
+                self.signal_list = net_names
+            return self.export_properties()
 
     def export_properties(self):
         return {
@@ -84,7 +86,7 @@ class CfgOperations(CfgBase):
         """Imports operation information from JSON."""
         if self.op_cutout:
             polygon_points = self._pedb.cutout(**self.op_cutout.get_attributes())
-            if not "pyedb_cutout" in self._pedb.stackup.all_layers:
+            if "pyedb_cutout" not in self._pedb.stackup.all_layers:
                 self._pedb.stackup.add_document_layer(name="pyedb_cutout")
                 self._pedb.modeler.create_polygon(polygon_points, layer_name="pyedb_cutout", net_name="pyedb_cutout")
 
@@ -92,4 +94,8 @@ class CfgOperations(CfgBase):
 
     def get_data_from_db(self):
         self.op_cutout = CfgCutout(self._pedb)
-        return {"cutout": self.op_cutout.get_data_from_db()}
+        data_from_db = self.op_cutout.get_data_from_db()
+        if data_from_db:
+            return {"cutout": data_from_db}
+        else:
+            return {}

pyedb-0.29.0/src/pyedb/configuration/cfg_padstacks.py

@@ -0,0 +1,106 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+from pyedb.configuration.cfg_common import CfgBase
+
+
+class CfgPadstacks:
+    """Padstack data class."""
+
+    def __init__(self, pedb, padstack_dict=None):
+        self._pedb = pedb
+        self.definitions = []
+        self.instances = []
+        if padstack_dict:
+            for pdef in padstack_dict.get("definitions", []):
+                self.definitions.append(Definition(**pdef))
+            for inst in padstack_dict.get("instances", []):
+                self.instances.append(Instance(**inst))
+
+    def apply(self):
+        """Apply padstack definition and instances on layout."""
+        if self.definitions:
+            padstack_defs_layout = self._pedb.padstacks.definitions
+            for pdef in self.definitions:
+                pdef_layout = padstack_defs_layout[pdef.name]
+                pdef_layout.set_properties(**pdef.get_attributes())
+        if self.instances:
+            instances_layout = self._pedb.padstacks.instances_by_name
+            for inst in self.instances:
+                inst_layout = instances_layout[inst.name]
+                if inst.definition:
+                    # inst_layout.padstack_definition = inst.definition
+                    # Not supported by EDB API
+                    pass
+                if inst.backdrill_parameters:
+                    inst_layout.backdrill_parameters = inst.backdrill_parameters
+
+    def get_data_from_db(self):
+        self.definitions = []
+        for pdef_name, pdef in self._pedb.padstacks.definitions.items():
+            self.definitions.append(
+                Definition(
+                    name=pdef_name,
+                    hole_plating_thickness=pdef.hole_plating_thickness,
+                    hole_material=pdef.material,
+                    hole_range=pdef.hole_range,
+                    pad_parameters=pdef.pad_parameters,
+                    hole_parameters=pdef.hole_parameters,
+                )
+            )
+        data = {}
+        definitions = []
+        for i in self.definitions:
+            definitions.append(i.get_attributes())
+        data["definitions"] = definitions
+
+        instances_layout = self._pedb.padstacks.instances_by_name
+        for name, obj in instances_layout.items():
+            self.instances.append(
+                Instance(name=name, definition=obj.padstack_definition, backdrill_parameters=obj.backdrill_parameters)
+            )
+        instances = []
+        for i in self.instances:
+            instances.append(i.get_attributes())
+        data["instances"] = instances
+        return data
+
+
+class Definition(CfgBase):
+    """Padstack definition data class."""
+
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name", None)
+        self.hole_plating_thickness = kwargs.get("hole_plating_thickness", None)
+        self.material = kwargs.get("hole_material", None)
+        self.hole_range = kwargs.get("hole_range", None)
+        self.pad_parameters = kwargs.get("pad_parameters", None)
+        self.hole_parameters = kwargs.get("hole_parameters", None)
+
+
+class Instance(CfgBase):
+    """Instance data class."""
+
+    def __init__(self, **kwargs):
+        self.name = kwargs["name"]
+        self.definition = kwargs.get("definition", None)
+        self.backdrill_parameters = kwargs.get("backdrill_parameters", None)

{pyedb-0.27.0 → pyedb-0.29.0}/src/pyedb/configuration/cfg_pin_groups.py

@@ -36,12 +36,14 @@ class CfgPinGroups:
 
     def get_data_from_db(self):
         self.pin_groups = []
-        for name, pg in self._pedb.siwave.pin_groups.items():
-            pins = [p.aedt_name for p in pg.pins.values()]
+        layout_pin_groups = self._pedb.siwave.pin_groups
+        for pg_name, pg_obj in layout_pin_groups.items():
+            pins = list(pg_obj.pins.keys())
+            refdes = list(pg_obj.pins.values())[0].component.name
             cfg_pg = CfgPinGroup(
                 self._pedb,
-                name=name,
-                reference_designator=None,
+                name=pg_name,
+                reference_designator=refdes,
                 pins=pins,
             )
             self.pin_groups.append(cfg_pg)
@@ -65,10 +67,7 @@ class CfgPinGroup(CfgBase):
     def create(self):
         """Apply pin group on layout."""
         if self.pins:
-            if self.reference_designator is None:
-                self._pedb.modeler.create_pin_group(self.name, pins_by_aedt_name=self.pins)
-            else:
-                self._pedb.siwave.create_pin_group(self.reference_designator, list(self.pins), self.name)
+            self._pedb.siwave.create_pin_group(self.reference_designator, list(self.pins), self.name)
         elif self.net:
             if self.reference_designator in self._pedb.components.instances:
                 comp = self._pedb.components.instances[self.reference_designator]

{pyedb-0.27.0 → pyedb-0.29.0}/src/pyedb/configuration/cfg_ports_sources.py

@@ -337,13 +337,15 @@ class CfgPort(CfgCircuitElement):
         return circuit_elements
 
     def export_properties(self):
-        return {
+        data = {
             "name": self.name,
             "type": self.type,
             "reference_designator": self.reference_designator,
             "positive_terminal": self.positive_terminal_info.export_properties(),
-            "negative_terminal": self.negative_terminal_info.export_properties(),
         }
+        if self.negative_terminal_info:
+            data.update({"negative_terminal": self.negative_terminal_info.export_properties()})
+        return data
 
 
 class CfgSource(CfgCircuitElement):

pyedb-0.29.0/src/pyedb/configuration/cfg_s_parameter_models.py

@@ -0,0 +1,116 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+from pathlib import Path
+
+
+class CfgSParameterModel:
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name", "")
+        self.component_definition = kwargs.get("component_definition", "")
+        self.file_path = kwargs.get("file_path", "")
+        self.apply_to_all = kwargs.get("apply_to_all", False)
+        self.components = kwargs.get("components", [])
+        self.reference_net = kwargs.get("reference_net", "")
+        self.reference_net_per_component = kwargs.get("reference_net_per_component", {})
+        self.pin_order = kwargs.get("pin_order", None)
+
+
+class CfgSParameters:
+    def __init__(self, pedb, data, path_lib=None):
+        self._pedb = pedb
+        self.path_libraries = path_lib
+        self.s_parameters_models = [CfgSParameterModel(**i) for i in data]
+
+    def apply(self):
+        for s_param in self.s_parameters_models:
+            fpath = s_param.file_path
+            if not Path(fpath).anchor:
+                fpath = str(Path(self.path_libraries) / fpath)
+            comp_def = self._pedb.definitions.component[s_param.component_definition]
+            if s_param.pin_order:
+                comp_def.set_properties(pin_order=s_param.pin_order)
+            comp_def.add_n_port_model(fpath, s_param.name)
+            comp_list = dict()
+            if s_param.apply_to_all:
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in s_param.components}
+                )
+            else:
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes in s_param.components}
+                )
+
+            for refdes, comp in comp_list.items():
+                if refdes in s_param.reference_net_per_component:
+                    ref_net = s_param.reference_net_per_component[refdes]
+                else:
+                    ref_net = s_param.reference_net
+                comp.use_s_parameter_model(s_param.name, reference_net=ref_net)
+
+    def get_data_from_db(self):
+        db_comp_def = self._pedb.definitions.component
+        for name, compdef_obj in db_comp_def.items():
+            nport_models = compdef_obj.component_models
+            if not nport_models:
+                continue
+            else:
+                pin_order = compdef_obj.get_properties()["pin_order"]
+                temp_comps = compdef_obj.components
+                for model_name, model_obj in nport_models.items():
+                    temp_comp_list = []
+                    reference_net_per_component = {}
+                    for i in temp_comps.values():
+                        s_param_model = i.model_properties.get("s_parameter_model")
+                        if s_param_model:
+                            if s_param_model["model_name"] == model_name:
+                                temp_comp_list.append(i.refdes)
+                                reference_net_per_component[i.refdes] = s_param_model["reference_net"]
+                        else:
+                            continue
+
+                    self.s_parameters_models.append(
+                        CfgSParameterModel(
+                            name=model_name,
+                            component_definition=name,
+                            file_path=model_obj.reference_file,
+                            apply_to_all=False,
+                            components=temp_comp_list,
+                            reference_net_per_component=reference_net_per_component,
+                            pin_order=pin_order,
+                        )
+                    )
+
+        data = []
+        for i in self.s_parameters_models:
+            data.append(
+                {
+                    "name": i.name,
+                    "component_definition": i.component_definition,
+                    "file_path": i.file_path,
+                    "apply_to_all": i.apply_to_all,
+                    "components": i.components,
+                    "reference_net_per_component": i.reference_net_per_component,
+                    "pin_order": i.pin_order,
+                }
+            )
+        return data