pyedb 0.12.2__py3-none-any.whl → 0.13.dev0__py3-none-any.whl

pyedb/__init__.py

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

pyedb/configuration/cfg_common.py

@@ -0,0 +1,48 @@
+# 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.generic.general_methods import pyedb_function_handler
+
+
+class CfgBase:
+    @property
+    def protected_attributes(self):
+        return []
+
+    @pyedb_function_handler
+    def get_attributes(self, exclude=None):
+        attrs = {i: j for i, j in self.__dict__.items() if i not in self.protected_attributes}
+        if exclude is not None:
+            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}
+        return attrs
+
+    @pyedb_function_handler
+    def set_attributes(self, pedb_object):
+        attrs = self.get_attributes()
+        for attr, value in attrs.items():
+            if attr not in dir(pedb_object):
+                raise AttributeError(f"Invalid attribute '{attr}' in '{pedb_object}'")
+            setattr(pedb_object, attr, value)

pyedb/configuration/cfg_components.py

@@ -20,186 +20,114 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from enum import Enum
-
-
-class CfgRlcModel:
-    def __init__(self):
-        self.resistance = 0.0
-        self.inductance = 0.0
-        self.capacitance = 0.0
-        self.rlc_model_type = self.RlcModelType.SERIES
-        self.enabled = False
-        self.pin_pairs = []
-
-    class RlcModelType(Enum):
-        SERIES = 0
-        PARALLEL = 1
-
-
-class CfgPortProperties:
-    def __init__(self):
-        self.ref_offset = 0.0
-        self.ref_size_auto = True
-        self.ref_size_x = 0.0
-        self.ref_size_y = 0.0
-
-
-class CfgSolderBallsProperties:
-    def __init__(self):
-        self.shape = self.Shape.CYLINDER
-        self.diameter = 0.0
-        self.mid_diameter = 0.0
-        self.height = 0.0
-        self.enable = True
-
-    class Shape(Enum):
-        CYLINDER = 0
-        SPHEROID = 1
-
-
-class CfgComponent:
-    def __init__(self, pdata, **kwargs):
-        self._pedb = pdata._pedb
-        self._comp_dict = kwargs
-        self.reference_designator = ""
-        self.part_type = self.ComponentType.RESISTOR
-        self.enabled = True
-        self.rlc_model = CfgRlcModel()
-        self.port_properties = CfgPortProperties()
-        self.solder_balls = CfgSolderBallsProperties()
-        self._update()
-        self.layout_comp = None
-
-    class ComponentType(Enum):
-        RESISTOR = 0
-        INDUCTOR = 1
-        CAPACITOR = 2
-        IO = 3
-        IC = 4
-        OTHER = 5
-
-    def _update(self):
-        self.reference_designator = self._comp_dict.get("reference_designator")
-        self.enabled = self._comp_dict.get("enabled")
-        part_type = self._comp_dict["part_type"].lower()
-        if part_type == "resistor":
-            self.part_type = self.part_type.RESISTOR
-        elif part_type == "capacitor":
-            self.part_type = self.part_type.CAPACITOR
-        elif part_type == "inductor":
-            self.part_type = self.part_type.INDUCTOR
-        elif part_type == "io":
-            self.part_type = self.part_type.IO
-        elif part_type == "ic":
-            self.part_type = self.part_type.IC
-        else:
-            self.part_type = self.part_type.OTHER
-
-        if self.part_type.value in [0, 1, 2]:
-            rlc_model = self._comp_dict["rlc_model"] if "rlc_model" in self._comp_dict else None
-            if rlc_model:
-                pin_pairs = rlc_model["pin_pairs"] if "pin_pairs" in rlc_model else None
-                if pin_pairs:
-                    self.rlc_model.pin_pairs = []
-                    for pp in pin_pairs:
-                        if pp["type"] == "Parallel":
-                            self.rlc_model.rlc_model_type = self.rlc_model.rlc_model_type.PARALLEL
-
-                        self.rlc_model.pin_pairs.append([pp["p1"], pp["p2"]])
-                        self.rlc_model.resistance = pp["resistance"] if "resistance" in pp else None
-                        self.rlc_model.inductance = pp["inductance"] if "inductance" in pp else None
-                        self.rlc_model.capacitance = pp["capacitance"] if "capacitance" in pp else None
-
-        port_properties = self._comp_dict["port_properties"] if "port_properties" in self._comp_dict else None
-        if port_properties:
-            self.port_properties.ref_offset = float(port_properties["reference_offset"])
-            self.port_properties.ref_size_auto = bool(port_properties["reference_size_auto"])
-            self.port_properties.ref_size_x = float(port_properties["reference_size_x"])
-            self.port_properties.ref_size_y = float(port_properties["reference_size_y"])
-
-        solder_ball_properties = (
-            self._comp_dict["solder_ball_properties"] if "solder_ball_properties" in self._comp_dict else None
+from pyedb.configuration.cfg_common import CfgBase
+from pyedb.generic.general_methods import pyedb_function_handler
+
+
+class CfgPortProperties(CfgBase):
+    def __init__(self, **kwargs):
+        self.reference_offset = kwargs.pop("reference_offset", 0)
+        self.reference_size_auto = kwargs.pop("reference_size_auto", 0)
+        self.reference_size_x = kwargs.pop("reference_size_x", 0)
+        self.reference_size_y = kwargs.pop("reference_size_y", 0)
+
+
+class CfgSolderBallsProperties(CfgBase):
+    def __init__(self, **kwargs):
+        self.shape = kwargs.pop("shape", None)
+        self.diameter = kwargs.pop("diameter", None)
+        self.mid_diameter = kwargs.pop("mid_diameter", None)
+        self.height = kwargs.pop("height", None)
+        self.enabled = kwargs.pop("enabled", None)
+
+
+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.type = kwargs.get("part_type", None)
+        self.value = kwargs.get("value", None)
+        self.port_properties = CfgPortProperties(**kwargs["port_properties"]) if "port_properties" in kwargs else None
+        self.solder_ball_properties = (
+            CfgSolderBallsProperties(**kwargs["solder_ball_properties"]) if "solder_ball_properties" in kwargs else None
         )
-        if solder_ball_properties:
-            if solder_ball_properties["shape"].lower() == "spheroid":
-                self.solder_balls.shape = self.solder_balls.shape.SPHEROID
-            self.solder_balls.diameter = solder_ball_properties["diameter"]
-            self.solder_balls.mid_diameter = (
-                float(solder_ball_properties["mid_diameter"])
-                if "mid_diameter" in solder_ball_properties
-                else self.solder_balls.diameter
-            )
-            self.solder_balls.height = solder_ball_properties["height"]
+        rlc_models = kwargs.get("rlc_model", [])
 
+        self.rlc_model = [CfgRlcModel(**rlc_m) for rlc_m in rlc_models]
+
+    @property
+    def protected_attributes(self):
+        return ["reference_designator"]
+
+
+class CfgComponents:
+    def __init__(self, pedb, data):
+        self._pedb = pedb
+        self.components = [CfgComponent(**comp) for comp in data]
+
+    @pyedb_function_handler
     def apply(self):
-        """Apply component on layout."""
-        self.layout_comp = self._pedb.components[self.reference_designator]
-        if self.layout_comp:
-            self._apply_part_type()
-            if self.part_type.name in ["CAPACITOR", "RESISTOR", "INDUCTOR"]:
-                self._apply_rlc_model()
-            else:
-                self._apply_solder_balls()
-
-    def _apply_part_type(self):
-        if self.part_type.name == "CAPACITOR":
-            self.layout_comp.type = "Capacitor"
-        elif self.part_type.name == "RESISTOR":
-            self.layout_comp.type = "Resistor"
-        elif self.part_type.name == "INDUCTOR":
-            self.layout_comp.type = "Inductor"
-        elif self.part_type.name == "IC":
-            self.layout_comp.type = "IC"
-        elif self.part_type.name == "IO":
-            self.layout_comp.type = "IO"
-        elif self.part_type.name == "OTHER":
-            self.layout_comp.type = "Other"
-
-    def _apply_rlc_model(self):
-        if self.part_type.value in [0, 1, 2]:
-            self.layout_comp.is_enabled = self.enabled
-            if self.rlc_model:
-                model_layout = self.layout_comp.model
-                if self.rlc_model.pin_pairs:
+        comps_in_db = self._pedb.components
+        for comp in self.components:
+            c_db = comps_in_db[comp.reference_designator]
+
+            for attr, value in comp.get_attributes().items():  # All component properties
+                if attr == "solder_ball_properties":
+                    solder_ball_properties = value
+                    port_properties = comp.port_properties
+                    self._pedb.components.set_solder_ball(
+                        component=comp.reference_designator,
+                        sball_diam=solder_ball_properties.diameter,
+                        sball_mid_diam=solder_ball_properties.mid_diameter,
+                        sball_height=solder_ball_properties.height,
+                        shape=solder_ball_properties.shape,
+                        auto_reference_size=port_properties.reference_size_auto,
+                        reference_height=port_properties.reference_offset,
+                        reference_size_x=port_properties.reference_size_x,
+                        reference_size_y=port_properties.reference_size_y,
+                    )
+                elif attr == "port_properties":
+                    pass
+                elif attr == "rlc_model":
+                    rlc_models = value
+                    model_layout = c_db.model
                     for pp in model_layout.pin_pairs:
                         model_layout.delete_pin_pair_rlc(pp)
-                    for pp in self.rlc_model.pin_pairs:
-                        pin_pair = self._pedb.edb_api.utility.PinPair(pp[0], pp[1])
+                    for pp in rlc_models:
+                        pin_pair = self._pedb.edb_api.utility.PinPair(pp.p1, pp.p2)
                         rlc = self._pedb.edb_api.utility.Rlc()
-                        rlc.IsParallel = False if self.rlc_model.rlc_model_type.SERIES else True
-                        if not self.rlc_model.resistance is None:
+                        rlc.IsParallel = False if pp.type else True
+                        if pp.resistance is not None:
                             rlc.REnabled = True
-                            rlc.R = self._pedb.edb_value(self.rlc_model.resistance)
+                            rlc.R = self._pedb.edb_value(pp.resistance)
                         else:
                             rlc.REnabled = False
-                        if not self.rlc_model.inductance is None:
+                        if pp.inductance is not None:
                             rlc.LEnabled = True
-                            rlc.L = self._pedb.edb_value(self.rlc_model.inductance)
+                            rlc.L = self._pedb.edb_value(pp.inductance)
                         else:
                             rlc.LEnabled = False
 
-                        if not self.rlc_model.capacitance is None:
+                        if pp.capacitance is not None:
                             rlc.CEnabled = True
-                            rlc.C = self._pedb.edb_value(self.rlc_model.capacitance)
+                            rlc.C = self._pedb.edb_value(pp.capacitance)
                         else:
                             rlc.CEnabled = False
                         model_layout._set_pin_pair_rlc(pin_pair, rlc)
-                        self.layout_comp.model = model_layout
-
-    def _apply_solder_balls(self):
-        if self.solder_balls.enable:
-            shape = "Cylinder"
-            if self.solder_balls.shape == self.solder_balls.shape.SPHEROID:
-                shape = "Spheroid"
-            self._pedb.components.set_solder_ball(
-                component=self.reference_designator,
-                sball_diam=self.solder_balls.diameter,
-                sball_mid_diam=self.solder_balls.mid_diameter,
-                sball_height=self.solder_balls.height,
-                shape=shape,
-                auto_reference_size=self.port_properties.ref_size_auto,
-                reference_height=self.port_properties.ref_offset,
-                reference_size_x=self.port_properties.ref_size_x,
-                reference_size_y=self.port_properties.ref_size_y,
-            )
+                        comps_in_db.model = model_layout
+                else:
+                    if attr in dir(c_db):
+                        setattr(c_db, attr, value)
+                    else:
+                        raise AttributeError(f"'{attr}' is not valid component attribute.")

pyedb/configuration/cfg_data.py

@@ -20,10 +20,13 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+
 from pyedb.configuration.cfg_boundaries import CfgBoundaries
-from pyedb.configuration.cfg_components import CfgComponent
+from pyedb.configuration.cfg_components import CfgComponents
 from pyedb.configuration.cfg_general import CfgGeneral
 from pyedb.configuration.cfg_nets import CfgNets
+from pyedb.configuration.cfg_operations import CfgOperations
+from pyedb.configuration.cfg_package_definition import CfgPackageDefinitions
 from pyedb.configuration.cfg_padstacks import CfgPadstacks
 from pyedb.configuration.cfg_pin_groups import CfgPinGroup
 from pyedb.configuration.cfg_ports_sources import CfgPort, CfgSources
@@ -31,7 +34,6 @@ from pyedb.configuration.cfg_s_parameter_models import CfgSParameterModel
 from pyedb.configuration.cfg_setup import CfgSetup
 from pyedb.configuration.cfg_spice_models import CfgSpiceModel
 from pyedb.configuration.cfg_stackup import CfgStackup
-from pyedb.generic.general_methods import pyedb_function_handler
 
 
 class CfgData(object):
@@ -52,7 +54,8 @@ class CfgData(object):
                 self, kwargs.get("nets", {}).get("signal_nets", []), kwargs.get("nets", {}).get("power_ground_nets", [])
             )
 
-        self.components = [CfgComponent(self, **component) for component in kwargs.get("components", [])]
+        # self.components = [CfgComponent(self, **component) for component in kwargs.get("components", [])]
+        self.components = CfgComponents(self._pedb, data=kwargs.get("components", []))
 
         self.padstacks = CfgPadstacks(self, kwargs.get("padstacks", None))
 
@@ -78,10 +81,5 @@ class CfgData(object):
             for spice_model in kwargs.get("spice_models", [])
         ]
 
-        self.package_definition = None
-        self.operations = None
-
-    @pyedb_function_handler
-    def apply(self):
-        """Apply configuration settings to the current design"""
-        self.stackup.apply()
+        self.package_definitions = CfgPackageDefinitions(self._pedb, data=kwargs.get("package_definitions", []))
+        self.operations = CfgOperations(self._pedb, data=kwargs.get("operations", []))

pyedb/configuration/cfg_operations.py

@@ -0,0 +1,63 @@
+# 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.generic.general_methods import pyedb_function_handler
+
+
+class CfgCutout(CfgBase):
+    def __init__(self, **kwargs):
+        self.signal_list = kwargs.get("signal_list")
+        self.reference_list = kwargs.get("reference_list")
+        self.extent_type = kwargs.get("extent_type")
+        self.expansion_size = kwargs.get("expansion_size")
+        self.use_round_corner = kwargs.get("use_round_corner")
+        self.output_aedb_path = kwargs.get("output_aedb_path")
+        self.open_cutout_at_end = kwargs.get("open_cutout_at_end")
+        self.use_pyaedt_cutout = kwargs.get("use_pyaedt_cutout")
+        self.number_of_threads = kwargs.get("number_of_threads")
+        self.use_pyaedt_extent_computing = kwargs.get("use_pyaedt_extent_computing")
+        self.extent_defeature = kwargs.get("extent_defeature")
+        self.remove_single_pin_components = kwargs.get("remove_single_pin_components")
+        self.custom_extent = kwargs.get("custom_extent")
+        self.custom_extent_units = kwargs.get("custom_extent_units")
+        self.include_partial_instances = kwargs.get("include_partial_instances")
+        self.keep_voids = kwargs.get("keep_voids")
+        self.check_terminals = kwargs.get("check_terminals")
+        self.include_pingroups = kwargs.get("include_pingroups")
+        self.expansion_factor = kwargs.get("expansion_factor")
+        self.maximum_iterations = kwargs.get("maximum_iterations")
+        self.preserve_components_with_model = kwargs.get("preserve_components_with_model")
+        self.simple_pad_check = kwargs.get("simple_pad_check")
+        self.keep_lines_as_path = kwargs.get("keep_lines_as_path")
+
+
+class CfgOperations(CfgBase):
+    def __init__(self, pedb, data):
+        self._pedb = pedb
+        self.op_cutout = CfgCutout(**data["cutout"]) if "cutout" in data else None
+
+    @pyedb_function_handler
+    def apply(self):
+        """Imports operation information from JSON."""
+        if self.op_cutout:
+            self._pedb.cutout(**self.op_cutout.get_attributes())

pyedb/configuration/cfg_package_definition.py

@@ -0,0 +1,128 @@
+# 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.edb_core.definition.package_def import PackageDef
+from pyedb.generic.general_methods import pyedb_function_handler
+
+
+class CfgPackage(CfgBase):
+    """Configuration package class."""
+
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name", None)
+        self.component_definition = kwargs.get("component_definition", None)
+        self.maximum_power = kwargs.get("maximum_power", None)
+        self.therm_cond = kwargs.get("therm_cond", None)
+        self.theta_jb = kwargs.get("theta_jb", None)
+        self.theta_jc = kwargs.get("theta_jc", None)
+        self.height = kwargs.get("height", None)
+        self.apply_to_all = kwargs.get("apply_to_all", None)
+        self.components = kwargs.get("components", [])
+        self.extent_bounding_box = kwargs.get("extent_bounding_box", None)
+        self._heatsink = CfgHeatSink(**kwargs["heatsink"]) if "heatsink" in kwargs else None
+
+    @property
+    def heatsink(self):
+        return self._heatsink
+
+    @heatsink.setter
+    def heatsink(self, value):
+        self._heatsink = value
+
+    @property
+    def protected_attributes(self):
+        """Attributes cannot be set to package definition class or don't exist in package definition class."""
+        return ["apply_to_all", "components", "extent_bounding_box", "component_definition"]
+
+
+class CfgHeatSink(CfgBase):
+    """Configuration heat sink class."""
+
+    def __init__(self, **kwargs):
+        self.fin_base_height = kwargs.get("fin_base_height", None)
+        self.fin_height = kwargs.get("fin_height", None)
+        self.fin_orientation = kwargs.get("fin_orientation", None)
+        self.fin_spacing = kwargs.get("fin_spacing", None)
+        self.fin_thickness = kwargs.get("fin_thickness", None)
+
+
+class CfgPackageDefinitions:
+    def __init__(self, pedb, data):
+        self._pedb = pedb
+        self.packages = [CfgPackage(**package) for package in data]
+
+    def apply(self):
+        for pkg in self.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
+
+    @pyedb_function_handler
+    def get_data_from_db(self):
+        package_definitions = []
+
+        for pkg_name, pkg_obj in self._pedb.definitions.package.items():
+            pkg = {}
+            pkg_attrs = [i for i in dir(pkg_obj) if not i.startswith("_")]
+            pkg_attrs = {i for i in pkg_attrs if i in CfgPackage().__dict__}
+            for pkg_attr_name in pkg_attrs:
+                pkg[pkg_attr_name] = getattr(pkg_obj, pkg_attr_name)
+
+            hs_obj = pkg_obj.heatsink
+            if hs_obj:
+                hs = {}
+                hs_attrs = [i for i in dir(hs_obj) if not i.startswith("_")]
+                hs_attrs = [i for i in hs_attrs if i in CfgHeatSink().__dict__]
+                for hs_attr_name in hs_attrs:
+                    hs[hs_attr_name] = getattr(hs_obj, hs_attr_name)
+                pkg["heatsink"] = hs
+            package_definitions.append(pkg)
+
+        return package_definitions