pyedb 0.53.0__tar.gz → 0.55.0__tar.gz

{pyedb-0.53.0 → pyedb-0.55.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyedb
-Version: 0.53.0
+Version: 0.55.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>
@@ -27,8 +27,7 @@ Requires-Dist: Rtree >= 1.2.0
 Requires-Dist: toml == 0.10.2
 Requires-Dist: shapely
 Requires-Dist: scikit-rf
-Requires-Dist: ansys-edb-core>=0.2.0.dev0
-Requires-Dist: ansys-api-edb>=0.2.0.dev0
+Requires-Dist: ansys-edb-core>=0.2.0
 Requires-Dist: psutil
 Requires-Dist: ansys-sphinx-theme>=1.0.0,<1.5 ; extra == "doc"
 Requires-Dist: imageio>=2.30.0,<2.38 ; extra == "doc"

{pyedb-0.53.0 → pyedb-0.55.0}/pyproject.toml

@@ -36,10 +36,9 @@ dependencies = [
     "toml == 0.10.2",
     "shapely",
     "scikit-rf",
-    "ansys-edb-core>=0.2.0.dev0",
-    "ansys-api-edb>=0.2.0.dev0",
+    "ansys-edb-core>=0.2.0",
     "psutil",
-    ]
+]
 
 [project.optional-dependencies]
 tests = [

{pyedb-0.53.0 → pyedb-0.55.0}/src/pyedb/__init__.py

@@ -3,13 +3,6 @@ import os
 import sys
 import warnings
 
-# if os.name == "nt":
-#     os.environ["PYTHONMALLOC"] = "malloc"
-
-# By default we use pyedb legacy implementation
-if "PYEDB_USE_DOTNET" not in os.environ:
-    os.environ["PYEDB_USE_DOTNET"] = "0"
-
 LATEST_DEPRECATED_PYTHON_VERSION = (3, 7)
 
 
@@ -44,7 +37,7 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.53.0"
+__version__ = "0.55.0"
 version = __version__
 
 #

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

@@ -0,0 +1,105 @@
+# 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.boundary_data = boundary_data
+
+        self.open_region = self.boundary_data.get("open_region", None)
+        self.open_region_type = self.boundary_data.get("map_open_region_type", None)
+        self.pml_visible = self.boundary_data.get("pml_visible", None)
+        self.pml_operation_frequency = self.boundary_data.get("pml_operation_frequency", None)
+        self.pml_radiation_factor = self.boundary_data.get("pml_radiation_factor", None)
+        self.dielectric_extent_type = self.boundary_data.get("dielectric_extent_type", None)
+        self.horizontal_padding = self.boundary_data.get("horizontal_padding", None)
+        self.honor_primitives_on_dielectric_layers = self.boundary_data.get(
+            "honor_primitives_on_dielectric_layers", False
+        )
+        self.air_box_extent_type = self.boundary_data.get("air_box_extent_type", None)
+        self.air_box_base_polygon = self.boundary_data.get("air_box_base_polygon", None)
+        self.air_box_truncate_model_ground_layers = self.boundary_data.get("air_box_truncate_model_ground_layers", None)
+        self.air_box_horizontal_padding = self.boundary_data.get("air_box_horizontal_padding", None)
+        self.air_box_positive_vertical_padding = self.boundary_data.get("air_box_positive_vertical_padding", None)
+        self.air_box_negative_vertical_padding = self.boundary_data.get("air_box_negative_vertical_padding", None)
+
+    def get_parameters_from_edb(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.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(exclude="boundary_data")
+
+    def set_parameters_to_edb(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:
+            if self._pedb.grpc:
+                self._pedb.hfss.hfss_extent_info.pml_radiation_factor = self.pml_radiation_factor
+            else:
+                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.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 apply(self):
+        """Imports boundary information from JSON."""
+        self.set_parameters_to_edb()
+
+    def get_data_from_db(self):
+        return self.get_parameters_from_edb()

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

@@ -0,0 +1,269 @@
+# 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
+from pyedb.dotnet.database.general import pascal_to_snake, snake_to_pascal
+
+
+class CfgComponent(CfgBase):
+    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.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_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_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_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"],
+                )
+                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 _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
+
+        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"]))
+        solder_ball_prop.SetMaterialName(self.solder_ball_properties.get("material", "solder"))
+        cp.SetSolderBallProperty(solder_ball_prop)
+        self.pyedb_obj.component_property = cp
+
+    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_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()
+
+        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.solder_ball_properties = temp
+
+    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:
+            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
+
+    def set_parameters_to_edb(self):
+        if self.type:
+            self.pyedb_obj.type = self.type
+        if self.enabled is not None:
+            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()
+            self._set_solder_ball_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.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()
+            self._retrieve_solder_ball_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 __init__(self, _pedb, pedb_object, **kwargs):
+        self._pedb = _pedb
+        self.pyedb_obj = pedb_object
+
+        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", {"type": "no_die"})
+        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.components = []
+
+        if components_data:
+            for comp in components_data:
+                obj = self._pedb.components.instances[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()
+
+    def retrieve_parameters_from_edb(self):
+        self.clean()
+        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()
+            self.components.append(cfg_comp)

{pyedb-0.53.0 → pyedb-0.55.0}/src/pyedb/configuration/cfg_data.py

@@ -48,7 +48,9 @@ class CfgData(object):
         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", [])
+            self._pedb,
+            kwargs.get("nets", {}).get("signal_nets", []),
+            kwargs.get("nets", {}).get("power_ground_nets", []),
         )
 
         self.components = CfgComponents(self._pedb, components_data=kwargs.get("components", []))
@@ -73,7 +75,7 @@ class CfgData(object):
         ]
 
         self.package_definitions = CfgPackageDefinitions(self._pedb, data=kwargs.get("package_definitions", []))
-        self.operations = CfgOperations(self._pedb, data=kwargs.get("operations", {}))
+        self.operations = CfgOperations(**kwargs.get("operations", {}))
 
         self.modeler = CfgModeler(self._pedb, data=kwargs.get("modeler", {}))
 

pyedb-0.55.0/src/pyedb/configuration/cfg_general.py

@@ -0,0 +1,50 @@
+# 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.
+
+
+class CfgGeneral:
+    """Manage configuration general settings."""
+
+    def set_parameters_to_edb(self):
+        if self.anti_pads_always_on is not None:
+            self.pedb.design_options.anti_pads_always_on = self.anti_pads_always_on
+        if self.suppress_pads is not None:
+            self.pedb.design_options.suppress_pads = self.suppress_pads
+
+    def get_parameters_from_edb(self):
+        anti_pads_always_on = self.pedb.design_options.antipads_always_on
+        suppress_pads = self.pedb.design_options.suppress_pads
+        data = {"anti_pads_always_on": anti_pads_always_on, "suppress_pads": suppress_pads}
+        return data
+
+    def __init__(self, pedb, data):
+        self.pedb = pedb
+        self.spice_model_library = data.get("spice_model_library", "")
+        self.s_parameter_library = data.get("s_parameter_library", "")
+        self.anti_pads_always_on = data.get("anti_pads_always_on", None)
+        self.suppress_pads = data.get("suppress_pads", None)
+
+    def apply(self):
+        self.set_parameters_to_edb()
+
+    def get_data_from_db(self):
+        return self.get_parameters_from_edb()

{pyedb-0.53.0 → pyedb-0.55.0}/src/pyedb/configuration/cfg_modeler.py

@@ -19,7 +19,7 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
-
+from copy import deepcopy as copy
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, TypedDict, Union
 
@@ -92,6 +92,7 @@ class CfgModeler:
             self.add_trace(**trace_data)
 
         for plane_data in data.get("planes", []):
+            plane_data = copy(plane_data)
             shape = plane_data.pop("type")
             if shape == "rectangle":
                 self.add_rectangular_plane(**plane_data)

{pyedb-0.53.0 → pyedb-0.55.0}/src/pyedb/configuration/cfg_nets.py

@@ -24,39 +24,25 @@
 class CfgNets:
     """Manage configuration net class."""
 
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
-
-        def set_parameter_to_edb(self):
-            for signal_net in self.parent.signal_nets:
-                if signal_net in self._pedb.nets:
-                    self._pedb.nets.nets[signal_net].is_power_ground = False
-            for power_net in self.parent.power_nets:
-                if power_net in self._pedb.nets:
-                    self._pedb.nets.nets[power_net].is_power_ground = True
-
-        def get_parameter_from_edb(self):
-            """Get net information."""
-            for net in self._pedb.nets.signal:
-                self.parent.signal_nets.append(net)
-            for net in self._pedb.nets.power:
-                self.parent.power_nets.append(net)
-            data = {"signal_nets": self.parent.signal_nets, "power_ground_nets": self.parent.power_nets}
-            return data
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            self.parent = parent
-            super().__init__(parent)
-
-    def __init__(self, pdata, signal_nets=None, power_nets=None):
-        self._pedb = pdata._pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
+    def set_parameter_to_edb(self):
+        for signal_net in self.signal_nets:
+            if signal_net in self._pedb.nets:
+                self._pedb.nets.nets[signal_net].is_power_ground = False
+        for power_net in self.power_nets:
+            if power_net in self._pedb.nets:
+                self._pedb.nets.nets[power_net].is_power_ground = True
+
+    def get_parameter_from_edb(self):
+        """Get net information."""
+        for net in self._pedb.nets.signal:
+            self.signal_nets.append(net)
+        for net in self._pedb.nets.power:
+            self.power_nets.append(net)
+        data = {"signal_nets": self.signal_nets, "power_ground_nets": self.power_nets}
+        return data
+
+    def __init__(self, pedb, signal_nets=None, power_nets=None):
+        self._pedb = pedb
         self.signal_nets = []
         self.power_nets = []
         if signal_nets:
@@ -66,8 +52,8 @@ class CfgNets:
 
     def apply(self):
         """Apply net on layout."""
-        self.api.set_parameter_to_edb()
+        self.set_parameter_to_edb()
 
     def get_data_from_db(self):
         """Get net information."""
-        return self.api.get_parameter_from_edb()
+        return self.get_parameter_from_edb()

pyedb-0.55.0/src/pyedb/configuration/cfg_operations.py

@@ -0,0 +1,51 @@
+# 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 typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+# from pyedb.configuration.cfg_common import CfgBase
+
+
+class CfgCutout(BaseModel):
+    auto_identify_nets: Optional[Dict] = {
+        "enabled": False,
+        "resistor_below": 100,
+        "inductor_below": 1,
+        "capacitor_above": 1,
+    }
+    signal_list: Optional[List[str]] = None
+    reference_list: Optional[List[str]] = None
+    extent_type: Optional[str] = "ConvexHull"
+    expansion_size: Optional[float] = 0.002
+    number_of_threads: Optional[int] = 1
+    custom_extent: Optional[Any] = None
+    custom_extent_units: str = Field(default="meter")
+    expansion_factor: Optional[float] = 0
+
+
+class CfgOperations(BaseModel):
+    cutout: Optional[CfgCutout] = None
+
+    def add_cutout(self, **kwargs):
+        self.cutout = CfgCutout(**kwargs)