pyedb 0.6.0__tar.gz → 0.7.0__tar.gz

{pyedb-0.6.0 → pyedb-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyedb
-Version: 0.6.0
+Version: 0.7.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>

{pyedb-0.6.0 → pyedb-0.7.0}/src/pyedb/__init__.py

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

{pyedb-0.6.0 → pyedb-0.7.0}/src/pyedb/dotnet/edb.py

@@ -4176,7 +4176,7 @@ class Edb(Database):
                 if via_holes:  # pragma no cover
                     hole_variable = self._clean_string_for_variable_name("$hole_diam_{}".format(def_name))
                     if hole_variable not in self.variables:
-                        self.add_design_variable(hole_variable, padstack_def.hole_properties[0])
+                        self.add_design_variable(hole_variable, padstack_def.hole_diameter_string)
                     padstack_def.hole_properties = hole_variable
                     parameters.append(hole_variable)
             if pads:
@@ -4186,7 +4186,7 @@ class Edb(Database):
                             "$pad_diam_{}_{}".format(def_name, layer)
                         )
                         if pad_diameter_variable not in self.variables:
-                            self.add_design_variable(pad_diameter_variable, pad.parameters_values[0])
+                            self.add_design_variable(pad_diameter_variable, pad.parameters_values_string[0])
                         pad.parameters = {"Diameter": pad_diameter_variable}
                         parameters.append(pad_diameter_variable)
                     if pad.geometry_type == 2:  # pragma no cover
@@ -4194,7 +4194,7 @@ class Edb(Database):
                             "$pad_size_{}_{}".format(def_name, layer)
                         )
                         if pad_size_variable not in self.variables:
-                            self.add_design_variable(pad_size_variable, pad.parameters_values[0])
+                            self.add_design_variable(pad_size_variable, pad.parameters_values_string[0])
                         pad.parameters = {"Size": pad_size_variable}
                         parameters.append(pad_size_variable)
                     elif pad.geometry_type == 3:  # pragma no cover
@@ -4205,8 +4205,8 @@ class Edb(Database):
                             "$pad_size_y_{}_{}".format(def_name, layer)
                         )
                         if pad_size_variable_x not in self.variables and pad_size_variable_y not in self.variables:
-                            self.add_design_variable(pad_size_variable_x, pad.parameters_values[0])
-                            self.add_design_variable(pad_size_variable_y, pad.parameters_values[1])
+                            self.add_design_variable(pad_size_variable_x, pad.parameters_values_string[0])
+                            self.add_design_variable(pad_size_variable_y, pad.parameters_values_string[1])
                         pad.parameters = {"XSize": pad_size_variable_x, "YSize": pad_size_variable_y}
                         parameters.append(pad_size_variable_x)
                         parameters.append(pad_size_variable_y)
@@ -4217,7 +4217,7 @@ class Edb(Database):
                             "$antipad_diam_{}_{}".format(def_name, layer)
                         )
                         if antipad_diameter_variable not in self.variables:  # pragma no cover
-                            self.add_design_variable(antipad_diameter_variable, antipad.parameters_values[0])
+                            self.add_design_variable(antipad_diameter_variable, antipad.parameters_values_string[0])
                         antipad.parameters = {"Diameter": antipad_diameter_variable}
                         parameters.append(antipad_diameter_variable)
                     if antipad.geometry_type == 2:  # pragma no cover
@@ -4225,7 +4225,7 @@ class Edb(Database):
                             "$antipad_size_{}_{}".format(def_name, layer)
                         )
                         if antipad_size_variable not in self.variables:  # pragma no cover
-                            self.add_design_variable(antipad_size_variable, antipad.parameters_values[0])
+                            self.add_design_variable(antipad_size_variable, antipad.parameters_values_string[0])
                         antipad.parameters = {"Size": antipad_size_variable}
                         parameters.append(antipad_size_variable)
                     elif antipad.geometry_type == 3:  # pragma no cover
@@ -4239,8 +4239,8 @@ class Edb(Database):
                             antipad_size_variable_x not in self.variables
                             and antipad_size_variable_y not in self.variables
                         ):  # pragma no cover
-                            self.add_design_variable(antipad_size_variable_x, antipad.parameters_values[0])
-                            self.add_design_variable(antipad_size_variable_y, antipad.parameters_values[1])
+                            self.add_design_variable(antipad_size_variable_x, antipad.parameters_values_string[0])
+                            self.add_design_variable(antipad_size_variable_y, antipad.parameters_values_string[1])
                         antipad.parameters = {"XSize": antipad_size_variable_x, "YSize": antipad_size_variable_y}
                         parameters.append(antipad_size_variable_x)
                         parameters.append(antipad_size_variable_y)

{pyedb-0.6.0 → pyedb-0.7.0}/src/pyedb/dotnet/edb_core/cell/hierarchy/model.py

@@ -86,3 +86,20 @@ class SParameterModel(Model):
 
     def component_model_name(self):
         self._edb_object.GetComponentModelName()
+
+
+class SPICEModel(Model):
+    """Manages SPICE model class."""
+
+    def __init__(self, pedb, edb_object=None):
+        super().__init__(pedb, edb_object)
+
+    @property
+    def model_name(self):
+        """SPICE model name."""
+        return self._edb_object.GetModelName()
+
+    @property
+    def spice_file_path(self):
+        """SPICE file path."""
+        return self._edb_object.GetSPICEFilePath()

{pyedb-0.6.0 → pyedb-0.7.0}/src/pyedb/dotnet/edb_core/configuration.py

@@ -41,6 +41,8 @@ class Configuration:
         self._pedb = pedb
         self._components = self._pedb.components.components
         self.data = {}
+        self._s_parameter_library = ""
+        self._spice_model_library = ""
 
     @pyedb_function_handler
     def load(self, config_file, append=True, apply_file=False, output_file=None, open_at_the_end=True):
@@ -92,9 +94,22 @@ class Configuration:
             self._pedb.logger.error("No data loaded. Please load a configuration file.")
             return False
 
+        # Configure general settings
+        if "general" in self.data:
+            self._load_general()
+
+        # Configure nets
+        if "nets" in self.data:
+            self._load_nets()
+
+        # Configure components
         if "components" in self.data:
             self._load_components()
 
+        # Configure pin groups
+        if "pin_groups" in self.data:
+            self._load_pin_groups()
+
         # Configure ports
         if "ports" in self.data:
             self._load_ports()
@@ -115,6 +130,10 @@ class Configuration:
         if "s_parameters" in self.data:
             self._load_s_parameter()
 
+        # Configure SPICE models
+        if "spice_models" in self.data:
+            self._load_spice_models()
+
         return True
 
     @pyedb_function_handler
@@ -122,7 +141,7 @@ class Configuration:
         """Imports component information from json."""
 
         for comp in self.data["components"]:
-            refdes = comp["reference_designator"]
+            ref_designator = comp["reference_designator"]
             part_type = comp["part_type"].lower()
             if part_type == "resistor":
                 part_type = "Resistor"
@@ -137,7 +156,7 @@ class Configuration:
             else:
                 part_type = "Other"
 
-            comp_layout = self._components[refdes]
+            comp_layout = self._components[ref_designator]
             comp_layout.type = part_type
 
             if part_type in ["Resistor", "Capacitor", "Inductor"]:
@@ -213,7 +232,7 @@ class Configuration:
                 height = solder_ball_properties["height"]
 
                 self._pedb.components.set_solder_ball(
-                    component=refdes,
+                    component=ref_designator,
                     sball_diam=diameter,
                     sball_mid_diam=mid_diameter,
                     sball_height=height,
@@ -229,38 +248,48 @@ class Configuration:
         """Imports port information from json."""
         for port in self.data["ports"]:
             port_type = port["type"]
-            refdes = port["reference_designator"]
-            comp_layout = self._components[refdes]
-            pos = port["from"]
-            if "pin" in pos:
-                pin_name = pos["pin"]
-                port_name = "{}_{}".format(refdes, pin_name)
-                pos_terminal = comp_layout.pins[pin_name].get_terminal(port_name, True)
-            else:  # Net
-                net_name = pos["net"]
-                port_name = "{}_{}".format(refdes, net_name)
-                if port_type == "circuit":
-                    pg_name = "pg_{}".format(port_name)
-                    _, pg = self._pedb.siwave.create_pin_group_on_net(refdes, net_name, pg_name)
-                    pos_terminal = pg.get_terminal(port_name, True)
-                else:  # Coax port
-                    for _, p in comp_layout.pins.items():
-                        if p.net_name == net_name:
-                            pos_terminal = p.get_terminal(port_name, True)
-                            break
+
+            positive_terminal_json = port["positive_terminal"]
+            pos_terminal = ""
+            if "pin_group" in positive_terminal_json:
+                pin_group = self._pedb.siwave.pin_groups[positive_terminal_json["pin_group"]]
+                pos_terminal = pin_group.get_terminal(pin_group.name, True)
+            else:
+                ref_designator = port["reference_designator"]
+                comp_layout = self._components[ref_designator]
+
+                if "pin" in positive_terminal_json:
+                    pin_name = positive_terminal_json["pin"]
+                    port_name = "{}_{}".format(ref_designator, pin_name)
+                    pos_terminal = comp_layout.pins[pin_name].get_terminal(port_name, True)
+                else:  # Net
+                    net_name = positive_terminal_json["net"]
+                    port_name = "{}_{}".format(ref_designator, net_name)
+                    if port_type == "circuit":
+                        pg_name = "pg_{}".format(port_name)
+                        _, pg = self._pedb.siwave.create_pin_group_on_net(ref_designator, net_name, pg_name)
+                        pos_terminal = pg.get_terminal(port_name, True)
+                    else:  # Coax port
+                        for _, p in comp_layout.pins.items():
+                            if p.net_name == net_name:
+                                pos_terminal = p.get_terminal(port_name, True)
+                                break
 
             if port_type == "circuit":
-                neg = port["to"]
-                if "pin" in neg:
-                    pin_name = neg["pin"]
-                    port_name = "{}_{}_ref".format(refdes, pin_name)
+                negative_terminal_json = port["negative_terminal"]
+                if "pin_group" in negative_terminal_json:
+                    pin_group = self._pedb.siwave.pin_groups[negative_terminal_json["pin_group"]]
+                    neg_terminal = pin_group.get_terminal(pin_group.name + "_ref", True)
+                elif "pin" in negative_terminal_json:
+                    pin_name = negative_terminal_json["pin"]
+                    port_name = "{}_{}_ref".format(ref_designator, pin_name)
                     neg_terminal = comp_layout.pins[pin_name].get_terminal(port_name, True)
                 else:
-                    net_name = neg["net"]
-                    port_name = "{}_{}_ref".format(refdes, net_name)
+                    net_name = negative_terminal_json["net"]
+                    port_name = "{}_{}_ref".format(ref_designator, net_name)
                     pg_name = "pg_{}".format(port_name)
                     if pg_name not in self._pedb.siwave.pin_groups:
-                        _, pg = self._pedb.siwave.create_pin_group_on_net(refdes, net_name, pg_name)
+                        _, pg = self._pedb.siwave.create_pin_group_on_net(ref_designator, net_name, pg_name)
                     else:
                         pg = self._pedb.siwave.pin_groups[pg_name]
                     neg_terminal = pg.get_terminal(port_name, True)
@@ -275,36 +304,47 @@ class Configuration:
 
         for src in self.data["sources"]:
             src_type = src["type"]
-            refdes = src["reference_designator"]
             name = src["name"]
-            comp_layout = self._components[refdes]
-
-            pos = src["from"]
-            if "pin" in pos:
-                pin_name = pos["pin"]
-                src_name = name
-                pos_terminal = comp_layout.pins[pin_name].get_terminal(src_name, True)
-            elif "net" in pos:  # Net
-                net_name = pos["net"]
-                src_name = "{}_{}".format(refdes, net_name)
-                pg_name = "pg_{}".format(src_name)
-                _, pg = self._pedb.siwave.create_pin_group_on_net(refdes, net_name, pg_name)
-                pos_terminal = pg.get_terminal(src_name, True)
-
-            neg = src["to"]
-            if "pin" in neg:
-                pin_name = neg["pin"]
-                src_name = name + "_ref"
-                neg_terminal = comp_layout.pins[pin_name].get_terminal(src_name, True)
-            elif "net" in neg:
-                net_name = neg["net"]
-                src_name = name + "_ref"
-                pg_name = "pg_{}".format(src_name)
-                if pg_name not in self._pedb.siwave.pin_groups:
-                    _, pg = self._pedb.siwave.create_pin_group_on_net(refdes, net_name, pg_name)
-                else:  # pragma no cover
-                    pg = self._pedb.siwave.pin_groups[pg_name]
-                neg_terminal = pg.get_terminal(src_name, True)
+
+            positive_terminal_json = src["positive_terminal"]
+            if "pin_group" in positive_terminal_json:
+                pin_group = self._pedb.siwave.pin_groups[positive_terminal_json["pin_group"]]
+                pos_terminal = pin_group.get_terminal(pin_group.name, True)
+            else:
+                ref_designator = src["reference_designator"]
+                comp_layout = self._components[ref_designator]
+
+                if "pin" in positive_terminal_json:
+                    pin_name = positive_terminal_json["pin"]
+                    src_name = name
+                    pos_terminal = comp_layout.pins[pin_name].get_terminal(src_name, True)
+                elif "net" in positive_terminal_json:  # Net
+                    net_name = positive_terminal_json["net"]
+                    src_name = "{}_{}".format(ref_designator, net_name)
+                    pg_name = "pg_{}".format(src_name)
+                    _, pg = self._pedb.siwave.create_pin_group_on_net(ref_designator, net_name, pg_name)
+                    pos_terminal = pg.get_terminal(src_name, True)
+
+            negative_terminal_json = src["negative_terminal"]
+            if "pin_group" in negative_terminal_json:
+                pin_group = self._pedb.siwave.pin_groups[negative_terminal_json["pin_group"]]
+                neg_terminal = pin_group.get_terminal(pin_group.name + "_ref", True)
+            else:
+                ref_designator = src["reference_designator"]
+                comp_layout = self._components[ref_designator]
+                if "pin" in negative_terminal_json:
+                    pin_name = negative_terminal_json["pin"]
+                    src_name = name + "_ref"
+                    neg_terminal = comp_layout.pins[pin_name].get_terminal(src_name, True)
+                elif "net" in negative_terminal_json:
+                    net_name = negative_terminal_json["net"]
+                    src_name = name + "_ref"
+                    pg_name = "pg_{}".format(src_name)
+                    if pg_name not in self._pedb.siwave.pin_groups:
+                        _, pg = self._pedb.siwave.create_pin_group_on_net(ref_designator, net_name, pg_name)
+                    else:  # pragma no cover
+                        pg = self._pedb.siwave.pin_groups[pg_name]
+                    neg_terminal = pg.get_terminal(src_name, True)
 
             if src_type == "voltage":
                 src_obj = self._pedb.create_voltage_source(pos_terminal, neg_terminal)
@@ -430,6 +470,8 @@ class Configuration:
 
         for sp in self.data["s_parameters"]:
             fpath = sp["file_path"]
+            if not Path(fpath).anchor:
+                fpath = str(Path(self._s_parameter_library) / fpath)
             sp_name = sp["name"]
             comp_def_name = sp["component_definition"]
             comp_def = self._pedb.definitions.component[comp_def_name]
@@ -442,3 +484,55 @@ class Configuration:
                 for refdes, comp in comp_def.components.items():
                     if refdes in sp["components"]:
                         comp.use_s_parameter_model(sp_name)
+
+    @pyedb_function_handler
+    def _load_spice_models(self):
+        """Imports SPICE information from json."""
+
+        for sp in self.data["spice_models"]:
+            fpath = sp["file_path"]
+            if not Path(fpath).anchor:
+                fpath = str(Path(self._spice_model_library) / fpath)
+            sp_name = sp["name"]
+            sub_circuit_name = sp.get("sub_circuit_name", None)
+            comp_def_name = sp["component_definition"]
+            comp_def = self._pedb.definitions.component[comp_def_name]
+            comps = comp_def.components
+            if sp["apply_to_all"]:
+                for refdes, comp in comps.items():
+                    if refdes not in sp["components"]:
+                        comp.assign_spice_model(fpath, sp_name, sub_circuit_name)
+            else:
+                for refdes, comp in comps.items():
+                    if refdes in sp["components"]:
+                        comp.assign_spice_model(fpath, sp_name, sub_circuit_name)
+
+    @pyedb_function_handler
+    def _load_pin_groups(self):
+        """Imports pin groups information from JSON."""
+        for pg in self.data["pin_groups"]:
+            name = pg["name"]
+            ref_designator = pg["reference_designator"]
+            if "pins" in pg:
+                self._pedb.siwave.create_pin_group(ref_designator, pg["pins"], name)
+            elif "net" in pg:
+                self._pedb.siwave.create_pin_group_on_net(ref_designator, pg["net"], name)
+
+    @pyedb_function_handler
+    def _load_nets(self):
+        """Imports nets information from JSON."""
+        nets = self._pedb.nets.nets
+        for i in self.data["nets"]["power_ground_nets"]:
+            nets[i].is_power_ground = True
+
+        for i in self.data["nets"]["signal_nets"]:
+            nets[i].is_power_ground = False
+
+    @pyedb_function_handler
+    def _load_general(self):
+        """Imports general information from JSON."""
+        general = self.data["general"]
+        if "s_parameter_library" in general:
+            self._s_parameter_library = general["s_parameter_library"]
+        if "spice_model_library" in general:
+            self._spice_model_library = general["spice_model_library"]

{pyedb-0.6.0 → pyedb-0.7.0}/src/pyedb/dotnet/edb_core/edb_data/components_data.py

@@ -24,7 +24,7 @@ import logging
 import re
 import warnings
 
-from pyedb.dotnet.edb_core.cell.hierarchy.model import PinPairModel
+from pyedb.dotnet.edb_core.cell.hierarchy.model import PinPairModel, SPICEModel
 from pyedb.dotnet.edb_core.definition.package_def import PackageDef
 from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
 from pyedb.generic.general_methods import is_ironpython
@@ -222,6 +222,8 @@ class EDBComponent(object):
         model_type = edb_object.ToString().split(".")[-1]
         if model_type == "PinPairModel":
             return PinPairModel(self._pedb, edb_object)
+        elif model_type == "SPICEModel":
+            return SPICEModel(self._pedb, edb_object)
 
     @model.setter
     def model(self, value):
@@ -912,7 +914,7 @@ class EDBComponent(object):
         return True
 
     @pyedb_function_handler()
-    def assign_spice_model(self, file_path, name=None):
+    def assign_spice_model(self, file_path, name=None, sub_circuit_name=None):
         """Assign Spice model to this component.
 
         Parameters
@@ -940,6 +942,8 @@ class EDBComponent(object):
             model = self._edb.cell.hierarchy._hierarchy.SPICEModel()
             model.SetModelPath(file_path)
             model.SetModelName(name)
+            if sub_circuit_name:
+                model.SetSubCkt(sub_circuit_name)
             terminal = 1
             for pn in pinNames:
                 model.AddTerminalPinPair(pn, str(terminal))

{pyedb-0.6.0 → pyedb-0.7.0}/src/pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -144,6 +144,11 @@ class EDBPadProperties(object):
         """
         return [i.tofloat for i in self.parameters.values()]
 
+    @property
+    def parameters_values_string(self):
+        """Parameters value in string format."""
+        return [i.tostring for i in self.parameters.values()]
+
     @property
     def polygon_data(self):
         """Parameters.
@@ -499,6 +504,21 @@ class EDBPadstack(object):
         self._hole_parameters = self.hole_params[2]
         return self._hole_parameters
 
+    @property
+    def hole_diameter(self):
+        """Hole diameter."""
+        return list(self.hole_params[2])[0].ToDouble()
+
+    @hole_diameter.setter
+    def hole_diameter(self, value):
+        params = convert_py_list_to_net_list([self._get_edb_value(value)])
+        self._update_hole_parameters(params=params)
+
+    @property
+    def hole_diameter_string(self):
+        """Hole diameter in string format."""
+        return list(self.hole_params[2])[0].ToString()
+
     @pyedb_function_handler()
     def _update_hole_parameters(self, hole_type=None, params=None, offsetx=None, offsety=None, rotation=None):
         """Update hole parameters.

{pyedb-0.6.0 → pyedb-0.7.0}/src/pyedb/dotnet/edb_core/hfss.py

@@ -1165,7 +1165,7 @@ class EdbHfss(object):
                                     if not ref_prim:
                                         self._logger.error("Failed to collect valid reference primitives for terminal")
                                 if ref_prim:
-                                    reference_layer = ref_prim[0].layer
+                                    reference_layer = ref_prim[0].layer._edb_layer
                                     if term.SetReferenceLayer(reference_layer):  # pragma no cover
                                         self._logger.info("Port {} created".format(port_name))
             return terminal_info

{pyedb-0.6.0 → pyedb-0.7.0}/src/pyedb/dotnet/edb_core/layout.py

@@ -1126,7 +1126,7 @@ class EdbLayout(object):
         return True
 
     @pyedb_function_handler()
-    def unite_polygons_on_layer(self, layer_name=None, delete_padstack_gemometries=False, net_list=[]):
+    def unite_polygons_on_layer(self, layer_name=None, delete_padstack_gemometries=False, net_names_list=[]):
         """Try to unite all Polygons on specified layer.
 
         Parameters
@@ -1135,8 +1135,8 @@ class EdbLayout(object):
             Name of layer name to unite objects on. The default is ``None``, in which case all layers are taken.
         delete_padstack_gemometries : bool, optional
             Whether to delete all padstack geometries. The default is ``False``.
-        net_list : list[str] : optional
-            Net list filter. The default is ``[]``, in which case all nets are taken.
+        net_names_list : list[str] : optional
+            Net names list filter. The default is ``[]``, in which case all nets are taken.
 
         Returns
         -------
@@ -1151,6 +1151,9 @@ class EdbLayout(object):
         for lay in layer_name:
             self._logger.info("Uniting Objects on layer %s.", lay)
             poly_by_nets = {}
+            all_voids = []
+            list_polygon_data = []
+            delete_list = []
             if lay in list(self.polygons_by_layer.keys()):
                 for poly in self.polygons_by_layer[lay]:
                     if not poly.GetNet().GetName() in list(poly_by_nets.keys()):
@@ -1160,34 +1163,35 @@ class EdbLayout(object):
                         if poly.GetNet().GetName():
                             poly_by_nets[poly.GetNet().GetName()].append(poly)
             for net in poly_by_nets:
-                if net in net_list or not net_list:  # pragma no cover
-                    list_polygon_data = [i.GetPolygonData() for i in poly_by_nets[net]]
-                    all_voids = [i.Voids for i in poly_by_nets[net]]
-                    a = self._edb.geometry.polygon_data.unite(convert_py_list_to_net_list(list_polygon_data))
-                    for item in a:
-                        for v in all_voids:
-                            for void in v:
-                                if int(item.GetIntersectionType(void.GetPolygonData())) == 2:
-                                    item.AddHole(void.GetPolygonData())
-                        poly = self._edb.cell.primitive.polygon.create(
-                            self._active_layout,
-                            lay,
-                            self._pedb.nets.nets[net],
-                            item,
-                        )
-                    list_to_delete = [i for i in poly_by_nets[net]]
-                    for v in all_voids:
-                        for void in v:
-                            for poly in poly_by_nets[net]:  # pragma no cover
-                                if int(void.GetPolygonData().GetIntersectionType(poly.GetPolygonData())) >= 2:
-                                    try:
-                                        id = list_to_delete.index(poly)
-                                    except ValueError:
-                                        id = -1
-                                    if id >= 0:
-                                        list_to_delete.pop(id)
-
-                    [i.Delete() for i in list_to_delete]  # pragma no cover
+                if net in net_names_list or not net_names_list:
+                    for i in poly_by_nets[net]:
+                        list_polygon_data.append(i.GetPolygonData())
+                        delete_list.append(i)
+                        all_voids.append(i.Voids)
+            a = self._edb.geometry.polygon_data.unite(convert_py_list_to_net_list(list_polygon_data))
+            for item in a:
+                for v in all_voids:
+                    for void in v:
+                        if int(item.GetIntersectionType(void.GetPolygonData())) == 2:
+                            item.AddHole(void.GetPolygonData())
+                poly = self._edb.cell.primitive.polygon.create(
+                    self._active_layout,
+                    lay,
+                    self._pedb.nets.nets[net],
+                    item,
+                )
+            for v in all_voids:
+                for void in v:
+                    for poly in poly_by_nets[net]:  # pragma no cover
+                        if int(void.GetPolygonData().GetIntersectionType(poly.GetPolygonData())) >= 2:
+                            try:
+                                id = delete_list.index(poly)
+                            except ValueError:
+                                id = -1
+                            if id >= 0:
+                                delete_list.pop(id)
+            for poly in delete_list:
+                poly.Delete()
 
         if delete_padstack_gemometries:
             self._logger.info("Deleting Padstack Definitions")

{pyedb-0.6.0 → pyedb-0.7.0}/src/pyedb/dotnet/edb_core/nets.py

@@ -1218,12 +1218,12 @@ class EdbNets(object):
         )
 
     @pyedb_function_handler()
-    def merge_nets_polygons(self, net_list):
+    def merge_nets_polygons(self, net_names_list):
         """Convert paths from net into polygons, evaluate all connected polygons and perform the merge.
 
         Parameters
         ----------
-        net_list : str or list[str]
+        net_names_list : str or list[str]
             Net name of list of net name.
 
         Returns
@@ -1232,6 +1232,6 @@ class EdbNets(object):
             ``True`` when successful, ``False`` when failed.
 
         """
-        if isinstance(net_list, str):
-            net_list = [net_list]
-        return self._pedb.modeler.unite_polygons_on_layer(net_list=net_list)
+        if isinstance(net_names_list, str):
+            net_names_list = [net_names_list]
+        return self._pedb.modeler.unite_polygons_on_layer(net_names_list=net_names_list)