pyedb 0.43.0__py3-none-any.whl → 0.45.0__py3-none-any.whl

pyedb/__init__.py

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

pyedb/configuration/cfg_boundaries.py

@@ -79,7 +79,7 @@ class CfgBoundaries(CfgBase):
             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.parentair_box_positive_vertical_extent = float(
+                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:
@@ -88,20 +88,26 @@ class CfgBoundaries(CfgBase):
                 )
 
         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
-            self.pml_radiation_factor = self._pedb.hfss.hfss_extent_info.pml_radiation_factor
-            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.parent.get_attributes()
+            self.parent.open_region = self._pedb.hfss.hfss_extent_info.use_open_region
+            self.parent.open_region_type = self._pedb.hfss.hfss_extent_info.open_region_type
+            self.parent.pml_visible = self._pedb.hfss.hfss_extent_info.is_pml_visible
+            self.parent.pml_operation_frequency = self._pedb.hfss.hfss_extent_info.operating_freq
+            self.parent.pml_radiation_factor = self._pedb.hfss.hfss_extent_info.pml_radiation_factor
+            self.parent.dielectric_extent_type = self._pedb.hfss.hfss_extent_info.extent_type
+            self.parent.horizontal_padding = self._pedb.hfss.hfss_extent_info.dielectric_extent_size
+            self.parent.honor_primitives_on_dielectric_layers = self._pedb.hfss.hfss_extent_info.honor_user_dielectric
+            self.parent.air_box_extent_type = self._pedb.hfss.hfss_extent_info.extent_type
+            self.parent.air_box_truncate_model_ground_layers = (
+                self._pedb.hfss.hfss_extent_info.truncate_air_box_at_ground
+            )
+            self.parent.air_box_horizontal_padding = self._pedb.hfss.hfss_extent_info.air_box_horizontal_extent
+            self.parent.air_box_positive_vertical_padding = (
+                self._pedb.hfss.hfss_extent_info.air_box_positive_vertical_extent
+            )
+            self.parent.air_box_negative_vertical_padding = (
+                self._pedb.hfss.hfss_extent_info.air_box_negative_vertical_extent
+            )
+            return self.parent.get_attributes(exclude="boundary_data")
 
     class DotNet(Grpc):
         def __init__(self, parent):

pyedb/configuration/cfg_components.py

@@ -136,9 +136,9 @@ class CfgComponent(CfgBase):
             die_type = pascal_to_snake(ic_die_prop.die_type.name)
             temp["type"] = die_type
             if not die_type == "no_die":
-                temp["orientation"] = pascal_to_snake(ic_die_prop.die_orientation.name)
+                temp["orientation"] = ic_die_prop.die_orientation.name.lower()
                 if die_type == "wire_bond":
-                    temp["height"] = ic_die_prop.height.value
+                    temp["height"] = str(ic_die_prop.height.value)
 
             self.parent.ic_die_properties = temp
 
@@ -183,10 +183,10 @@ class CfgComponent(CfgBase):
                 uses_solder_ball = solder_ball_prop.uses_solderball
 
                 temp["uses_solder_ball"] = uses_solder_ball
-                temp["shape"] = pascal_to_snake(shape)
-                temp["diameter"] = diam
-                temp["mid_diameter"] = mid_diam
-                temp["height"] = height
+                temp["shape"] = shape.lower()
+                temp["diameter"] = str(diam)
+                temp["mid_diameter"] = str(mid_diam)
+                temp["height"] = str(height)
                 temp["material"] = material
 
                 self.parent.solder_ball_properties = temp
@@ -262,7 +262,7 @@ class CfgComponent(CfgBase):
         def set_parameters_to_edb(self):
             if self.parent.type:
                 self.pyedb_obj.type = self.parent.type
-            if self.parent.enabled:
+            if self.parent.enabled is not None:
                 self.pyedb_obj.enabled = self.parent.enabled
 
             self._set_model_properties_to_edb()
@@ -495,7 +495,7 @@ class CfgComponent(CfgBase):
 
         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.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", {})

pyedb/configuration/cfg_general.py

@@ -34,8 +34,8 @@ class CfgGeneral:
             self.pedb.active_cell.suppress_pads = self.parent.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
+            anti_pads_always_on = self.pedb.active_cell.anti_pads_always_on
+            suppress_pads = self.pedb.active_cell.suppress_pads
             data = {"anti_pads_always_on": anti_pads_always_on, "suppress_pads": suppress_pads}
             return data
 
@@ -44,8 +44,16 @@ class CfgGeneral:
             super().__init__(parent)
 
         def set_parameters_to_edb(self):
-            self.pedb.design_options.antipads_always_on = self.parent.anti_pads_always_on
-            self.pedb.design_options.suppress_pads = self.parent.suppress_pads
+            if self.parent.anti_pads_always_on is not None:
+                self.pedb.design_options.anti_pads_always_on = self.parent.anti_pads_always_on
+            if self.parent.suppress_pads is not None:
+                self.pedb.design_options.suppress_pads = self.parent.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
@@ -55,8 +63,8 @@ class CfgGeneral:
             self.api = self.DotNet(self)
         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", False)
-        self.suppress_pads = data.get("suppress_pads", True)
+        self.anti_pads_always_on = data.get("anti_pads_always_on", None)
+        self.suppress_pads = data.get("suppress_pads", None)
 
     def apply(self):
         self.api.set_parameters_to_edb()

pyedb/configuration/cfg_modeler.py

@@ -141,6 +141,11 @@ class CfgModeler:
                     c.pyedb_obj = obj
                     c.api.set_parameters_to_edb()
 
+        def delete_primitives(self):
+            primitives = self._pedb.layout.find_primitive(**self.parent.primitives_to_delete)
+            for i in primitives:
+                i.delete()
+
     class DotNet(Grpc):
         def __init__(self, parent):
             super().__init__(parent)
@@ -175,6 +180,7 @@ class CfgModeler:
                         net_name=p.net_name,
                         position=p.position,
                         definition_name=p.definition,
+                        rotation=p.rotation if p.rotation is not None else 0,
                     )
                     p.pyedb_obj = p_inst
                     p.api.set_parameters_to_edb()
@@ -229,6 +235,8 @@ class CfgModeler:
         ]
         self.planes = [CfgPlane(**i) for i in data.get("planes", [])]
         self.components = [CfgComponent(self._pedb, None, **i) for i in data.get("components", [])]
+        self.primitives_to_delete = data.get("primitives_to_delete", {"layer_name": [], "name": [], "net_name": []})
 
     def apply(self):
         self.api.set_parameter_to_edb()
+        self.api.delete_primitives()

pyedb/configuration/cfg_operations.py

@@ -56,6 +56,9 @@ class CfgCutout(CfgBase):
             self.api = self.Grpc(self)
         else:
             self.api = self.DotNet(self)
+        self.auto_identify_nets = kwargs.get(
+            "auto_identify_nets", {"enabled": False, "resistor_below": 100, "inductor_below": 1, "capacitor_above": 1}
+        )
         self.signal_list = kwargs.get("signal_list")
         self.reference_list = kwargs.get("reference_list")
         self.extent_type = kwargs.get("extent_type")
@@ -99,7 +102,43 @@ class CfgOperations(CfgBase):
 
         def apply_on_edb(self):
             if self.parent.op_cutout:
-                polygon_points = self._pedb.cutout(**self.parent.op_cutout.get_attributes())
+                cutout_params = self.parent.op_cutout.get_attributes()
+                auto_identify_nets = cutout_params.pop("auto_identify_nets")
+                if auto_identify_nets["enabled"]:
+                    reference_list = cutout_params.get("reference_list", [])
+                    if auto_identify_nets:
+                        self._pedb.nets.generate_extended_nets(
+                            auto_identify_nets["resistor_below"],
+                            auto_identify_nets["inductor_below"],
+                            auto_identify_nets["capacitor_above"],
+                            auto_identify_nets.get("exception_list", []),
+                        )
+                        signal_nets = []
+                        for i in self._pedb.ports.values():
+                            # Positive terminal
+                            extended_net = i.net.extended_net
+                            if extended_net:
+                                temp = [i2 for i2 in extended_net.nets.keys() if i2 not in reference_list]
+                                temp = [i2 for i2 in temp if i2 not in signal_nets]
+                                signal_nets.extend(temp)
+                            else:
+                                signal_nets.append(i.net.name)
+
+                            # Negative terminal
+                            ref_net = i.ref_terminal.net if i.ref_terminal else None
+                            if ref_net is None:
+                                continue
+                            elif ref_net.name not in reference_list:
+                                extended_net = ref_net.extended_net
+                                if extended_net:
+                                    temp = [i2 for i2 in extended_net.nets.keys() if i2 not in reference_list]
+                                    temp = [i2 for i2 in temp if i2 not in signal_nets]
+                                    signal_nets.extend(temp)
+                                else:
+                                    signal_nets.append(ref_net.name)
+
+                        cutout_params["signal_list"] = signal_nets
+                polygon_points = self._pedb.cutout(**cutout_params)
                 if "pyedb_cutout" not in self._pedb.stackup.all_layers:
                     self._pedb.stackup.add_document_layer(name="pyedb_cutout")
                     self._pedb.modeler.create_polygon(

pyedb/configuration/cfg_package_definition.py

@@ -21,7 +21,6 @@
 # SOFTWARE.
 
 from pyedb.configuration.cfg_common import CfgBase
-from pyedb.dotnet.database.definition.package_def import PackageDef
 
 
 class CfgPackage(CfgBase):
@@ -70,6 +69,8 @@ class CfgPackageDefinitions:
             self._pedb = parent._pedb
 
         def set_parameter_to_edb(self):
+            from pyedb.grpc.database.definition.package_def import PackageDef
+
             for pkg in self.parent.packages:
                 comp_def_from_db = self._pedb.definitions.component[pkg.component_definition]
                 if pkg.name in self._pedb.definitions.package:
@@ -130,6 +131,45 @@ class CfgPackageDefinitions:
         def __init__(self, parent):
             super().__init__(parent)
 
+        def set_parameter_to_edb(self):
+            from pyedb.dotnet.database.definition.package_def import PackageDef
+
+            for pkg in self.parent.packages:
+                comp_def_from_db = self._pedb.definitions.component[pkg.component_definition]
+                if pkg.name in self._pedb.definitions.package:
+                    self._pedb.definitions.package[pkg.name].delete()
+
+                if pkg.extent_bounding_box:
+                    package_def = PackageDef(self._pedb, name=pkg.name, extent_bounding_box=pkg.extent_bounding_box)
+                else:
+                    package_def = PackageDef(self._pedb, name=pkg.name, component_part_name=pkg.component_definition)
+                pkg.set_attributes(package_def)
+
+                if pkg.heatsink:
+                    attrs = pkg.heatsink.get_attributes()
+                    for attr, value in attrs.items():
+                        package_def.set_heatsink(**attrs)
+
+                comp_list = dict()
+                if pkg.apply_to_all:
+                    comp_list.update(
+                        {
+                            refdes: comp
+                            for refdes, comp in comp_def_from_db.components.items()
+                            if refdes not in pkg.components
+                        }
+                    )
+                else:
+                    comp_list.update(
+                        {
+                            refdes: comp
+                            for refdes, comp in comp_def_from_db.components.items()
+                            if refdes in pkg.components
+                        }
+                    )
+                for _, i in comp_list.items():
+                    i.package_def = pkg.name
+
     def __init__(self, pedb, data):
         self._pedb = pedb
         if self._pedb.grpc: