pyedb 0.12.2__tar.gz → 0.13.dev0__tar.gz

{pyedb-0.12.2 → pyedb-0.13.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyedb
-Version: 0.12.2
+Version: 0.13.dev0
 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.12.2 → pyedb-0.13.dev0}/src/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-0.13.dev0/src/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-0.13.dev0/src/pyedb/configuration/cfg_components.py

@@ -0,0 +1,133 @@
+# 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 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
+        )
+        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):
+        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 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 pp.type else True
+                        if pp.resistance is not None:
+                            rlc.REnabled = True
+                            rlc.R = self._pedb.edb_value(pp.resistance)
+                        else:
+                            rlc.REnabled = False
+                        if pp.inductance is not None:
+                            rlc.LEnabled = True
+                            rlc.L = self._pedb.edb_value(pp.inductance)
+                        else:
+                            rlc.LEnabled = False
+
+                        if pp.capacitance is not None:
+                            rlc.CEnabled = True
+                            rlc.C = self._pedb.edb_value(pp.capacitance)
+                        else:
+                            rlc.CEnabled = False
+                        model_layout._set_pin_pair_rlc(pin_pair, rlc)
+                        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-0.12.2 → pyedb-0.13.dev0}/src/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-0.13.dev0/src/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-0.13.dev0/src/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

{pyedb-0.12.2 → pyedb-0.13.dev0}/src/pyedb/configuration/cfg_stackup.py

@@ -20,34 +20,68 @@
 # 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 CfgMaterial(CfgBase):
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name", None)
+        self.permittivity = kwargs.get("permittivity", None)
+        self.conductivity = kwargs.get("conductivity", None)
+        self.dielectric_loss_tangent = kwargs.get("dielectric_loss_tangent", None)
+        self.magnetic_loss_tangent = kwargs.get("magnetic_loss_tangent", None)
+        self.mass_density = kwargs.get("mass_density", None)
+        self.permeability = kwargs.get("permeability", None)
+        self.poisson_ratio = kwargs.get("poisson_ratio", None)
+        self.specific_heat = kwargs.get("specific_heat", None)
+        self.thermal_conductivity = kwargs.get("thermal_conductivity", None)
+
+
+class CfgLayer(CfgBase):
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name", None)
+        self.type = kwargs.get("type", None)
+        self.material = kwargs.get("material", None)
+        self.fill_material = kwargs.get("fill_material", None)
+        self.thickness = kwargs.get("thickness", None)
+
+
 class CfgStackup:
     def __init__(self, pedb, data):
         self._pedb = pedb
 
-        self.materials = [CfgMaterial(self._pedb, **mat) for mat in data.get("materials", [])]
-        self.layers = [CfgLayer(self._pedb, **lay) for lay in data.get("layers", [])]
+        self.materials = [CfgMaterial(**mat) for mat in data.get("materials", [])]
+        self.layers = [CfgLayer(**lay) for lay in data.get("layers", [])]
 
     @pyedb_function_handler
     def apply(self):
         """Apply configuration settings to the current design"""
         if len(self.materials):
             self.__apply_materials()
+
+        input_signal_layers = [i for i in self.layers if i.type.lower() == "signal"]
+
         if len(self.layers):
-            self.__apply_layers()
+            if len(self._pedb.stackup.signal_layers) == 0:
+                self.__create_stackup()
+            elif not len(input_signal_layers) == len(self._pedb.stackup.signal_layers):
+                raise Exception(f"Input signal layer count do not match.")
+            else:
+                self.__apply_layers()
+
+    def __create_stackup(self):
+        layers = list()
+        layers.extend(self.layers)
+        for l_attrs in layers:
+            attrs = l_attrs.get_attributes()
+            self._pedb.stackup.add_layer_bottom(**attrs)
 
     @pyedb_function_handler
     def __apply_layers(self):
         """Apply layer settings to the current design"""
         layers = list()
         layers.extend(self.layers)
-        input_signal_layers = [i for i in layers if i.type.lower() == "signal"]
-        if not len(input_signal_layers) == len(self._pedb.stackup.signal_layers):
-            self._pedb.logger.error("Input signal layer count do not match.")
-            return False
 
         removal_list = []
         lc_signal_layers = []
@@ -66,9 +100,7 @@ class CfgStackup:
             if l.type == "signal":
                 layer_id = lc_signal_layers[signal_idx]
                 layer_name = id_name[layer_id]
-                attrs = {
-                    i: j for i, j in l.__dict__.items() if not i.startswith("_") and isinstance(j, (int, float, str))
-                }
+                attrs = l.get_attributes()
                 self._pedb.stackup.layers[layer_name].update(**attrs)
                 signal_idx = signal_idx + 1
 
@@ -79,13 +111,11 @@ class CfgStackup:
         if l.type == "signal":
             prev_layer_clone = self._pedb.stackup.layers[l.name]
         else:
-            attrs = {i: j for i, j in l.__dict__.items() if not i.startswith("_") and isinstance(j, (int, float, str))}
+            attrs = l.get_attributes()
             prev_layer_clone = self._pedb.stackup.add_layer_top(**attrs)
         for idx, l in enumerate(layers):
             if l.type == "dielectric":
-                attrs = {
-                    i: j for i, j in l.__dict__.items() if not i.startswith("_") and isinstance(j, (int, float, str))
-                }
+                attrs = l.get_attributes()
                 prev_layer_clone = self._pedb.stackup.add_layer_below(base_layer_name=prev_layer_clone.name, **attrs)
             elif l.type == "signal":
                 prev_layer_clone = self._pedb.stackup.layers[l.name]
@@ -98,38 +128,42 @@ class CfgStackup:
             if mat_in_cfg.name.lower() in materials_in_db:
                 self._pedb.materials.delete_material(materials_in_db[mat_in_cfg.name.lower()])
 
-            attrs = {
-                i: j
-                for i, j in mat_in_cfg.__dict__.items()
-                if not i.startswith("_") and isinstance(j, (int, float, str))
-            }
+            attrs = mat_in_cfg.get_attributes()
             mat = self._pedb.materials.add_material(**attrs)
 
+    @pyedb_function_handler
+    def __get_materials_from_db(self):
+        materials = []
+        for name, p in self._pedb.materials.materials.items():
+            mat = {}
+            for p_name in CfgMaterial().__dict__:
+                mat[p_name] = getattr(p, p_name)
+            materials.append(mat)
+        return materials
 
-class CfgMaterial:
-    def __init__(self, pedb, **kwargs):
-        self._pedb = pedb
-        self.name = kwargs.get("name")
-        self.permittivity = kwargs.get("permittivity", None)
-        self.conductivity = kwargs.get("conductivity", None)
-        self.dielectric_loss_tangent = kwargs.get("dielectric_loss_tangent", None)
-        self.magnetic_loss_tangent = kwargs.get("magnetic_loss_tangent", None)
-        self.mass_density = kwargs.get("mass_density", None)
-        self.permeability = kwargs.get("permeability", None)
-        self.poisson_ratio = kwargs.get("poisson_ratio", None)
-        self.specific_heat = kwargs.get("specific_heat", None)
-        self.thermal_conductivity = kwargs.get("thermal_conductivity", None)
-        self.youngs_modulus = kwargs.get("youngs_modulus", None)
-        self.thermal_expansion_coefficient = kwargs.get("thermal_expansion_coefficient", None)
-
+    @pyedb_function_handler
+    def __get_layers_from_db(self):
+        layers = []
+        for name, obj in self._pedb.stackup.all_layers.items():
+            layer = {}
+            for p_name in CfgLayer().__dict__:
+                p_value = getattr(obj, p_name, None)
+                if p_value is not None:
+                    layer[p_name] = getattr(obj, p_name)
+            layers.append(layer)
+        return layers
 
-class CfgLayer:
-    def __init__(self, pedb, **kwargs):
-        self._pedb = pedb
-        self.name = kwargs.get("name", None)
-        self.type = kwargs.get("type", None)
-        self.material = kwargs.get("material", None)
-        self.fill_material = kwargs.get("fill_material", None)
-        self.thickness = kwargs.get("thickness", None)
-        self.etch_factor = kwargs.get("etch_factor", None)
-        self.lower_elevation = kwargs.get("lower_elevation", None)
+    @pyedb_function_handler
+    def get_data_from_db(self):
+        """Get configuration data from layout.
+
+        Returns
+        -------
+        dict
+        """
+        stackup = {}
+        materials = self.__get_materials_from_db()
+        stackup["materials"] = materials
+        layers = self.__get_layers_from_db()
+        stackup["layers"] = layers
+        return stackup