pyedb 0.53.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

pyedb/configuration/cfg_data.py

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

pyedb/configuration/cfg_general.py

@@ -24,50 +24,27 @@
 class CfgGeneral:
     """Manage configuration general settings."""
 
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self.pedb = parent.pedb
-
-        def set_parameters_to_edb(self):
-            self.pedb.active_cell.anti_pads_always_on = self.parent.anti_pads_always_on
-            self.pedb.active_cell.suppress_pads = self.parent.suppress_pads
-
-        def get_parameters_from_edb(self):
-            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
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-        def set_parameters_to_edb(self):
-            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 set_parameters_to_edb(self):
+        if self.anti_pads_always_on is not None:
+            self.pedb.design_options.anti_pads_always_on = self.anti_pads_always_on
+        if self.suppress_pads is not None:
+            self.pedb.design_options.suppress_pads = self.suppress_pads
+
+    def get_parameters_from_edb(self):
+        anti_pads_always_on = self.pedb.design_options.antipads_always_on
+        suppress_pads = self.pedb.design_options.suppress_pads
+        data = {"anti_pads_always_on": anti_pads_always_on, "suppress_pads": suppress_pads}
+        return data
 
     def __init__(self, pedb, data):
         self.pedb = pedb
-        if self.pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            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", None)
         self.suppress_pads = data.get("suppress_pads", None)
 
     def apply(self):
-        self.api.set_parameters_to_edb()
+        self.set_parameters_to_edb()
 
     def get_data_from_db(self):
-        return self.api.get_parameters_from_edb()
+        return self.get_parameters_from_edb()

pyedb/configuration/cfg_modeler.py

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

pyedb/configuration/cfg_nets.py

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

pyedb/configuration/cfg_operations.py

@@ -20,161 +20,32 @@
 # 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 typing import Any, Dict, List, Optional
 
+from pydantic import BaseModel, Field
 
-class CfgCutout(CfgBase):
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
+# from pyedb.configuration.cfg_common import CfgBase
 
-        def get_parameters_from_edb(self):
-            if "pyedb_cutout" in self._pedb.stackup.all_layers:
-                polygons = self._pedb.layout.find_primitive(layer_name="pyedb_cutout")
-                if polygons:
-                    poly = polygons[0]
-                    self.parent.custom_extent = poly.polygon_data.points
-                    net_names = []
-                    for name, obj in self._pedb.nets.nets.items():
-                        if obj.primitives:
-                            if obj.primitives[0].layer.name == "pyedb_cutout":
-                                continue
-                            else:
-                                net_names.append(name)
-                    self.parent.reference_list = []
-                    self.parent.signal_list = net_names
-                return self.parent.export_properties()
 
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
+class CfgCutout(BaseModel):
+    auto_identify_nets: Optional[Dict] = {
+        "enabled": False,
+        "resistor_below": 100,
+        "inductor_below": 1,
+        "capacitor_above": 1,
+    }
+    signal_list: Optional[List[str]] = None
+    reference_list: Optional[List[str]] = None
+    extent_type: Optional[str] = "ConvexHull"
+    expansion_size: Optional[float] = 0.002
+    number_of_threads: Optional[int] = 1
+    custom_extent: Optional[Any] = None
+    custom_extent_units: str = Field(default="meter")
+    expansion_factor: Optional[float] = 0
 
-    def __init__(self, pedb, **kwargs):
-        self._pedb = pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
-        self.auto_identify_nets = kwargs.get("auto_identify_nets")
-        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", "meter")
-        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")
 
-    def get_data_from_db(self):
-        return self.api.get_parameters_from_edb()
+class CfgOperations(BaseModel):
+    cutout: Optional[CfgCutout] = None
 
-    def export_properties(self):
-        return {
-            "signal_list": self.signal_list,
-            "reference_list": self.reference_list,
-            "custom_extent": self.custom_extent,
-        }
-
-
-class CfgOperations(CfgBase):
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
-
-        def apply_on_edb(self):
-            if self.parent.op_cutout:
-                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(
-                        polygon_points, layer_name="pyedb_cutout", net_name="pyedb_cutout"
-                    )
-
-        def get_parameter_from_edb(self):
-            self.parent.op_cutout = CfgCutout(self._pedb)
-            data_from_db = self.parent.op_cutout.get_data_from_db()
-            if data_from_db:
-                return {"cutout": data_from_db}
-            else:
-                return {}
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-    def __init__(self, pedb, data):
-        self._pedb = pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
-        cutout = data.get("cutout", None)
-        if cutout:
-            auto_identify_nets = (
-                cutout.pop("auto_identify_nets")
-                if cutout.get("auto_identify_nets")
-                else {"enabled": False, "resistor_below": 100, "inductor_below": 1, "capacitor_above": 1}
-            )
-            self.op_cutout = CfgCutout(pedb, auto_identify_nets=auto_identify_nets, **cutout)
-        else:
-            self.op_cutout = None
-
-    def apply(self):
-        """Imports operation information from JSON."""
-        self.api.apply_on_edb()
-
-    def get_data_from_db(self):
-        return self.api.get_parameter_from_edb()
+    def add_cutout(self, **kwargs):
+        self.cutout = CfgCutout(**kwargs)

pyedb/configuration/cfg_package_definition.py

@@ -63,123 +63,67 @@ class CfgHeatSink(CfgBase):
 
 
 class CfgPackageDefinitions:
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            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:
-                    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 get_parameter_from_edb(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
-
-    class DotNet(Grpc):
-        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 get_parameter_from_edb(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
+
+    def set_parameter_to_edb(self):
+        from pyedb.dotnet.database.definition.package_def import PackageDef
+
+        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
 
     def __init__(self, pedb, data):
         self._pedb = pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
         self.packages = [CfgPackage(**package) for package in data]
 
     def apply(self):
-        self.api.set_parameter_to_edb()
+        self.set_parameter_to_edb()
 
     def get_data_from_db(self):
-        return self.api.get_parameter_from_edb()
+        return self.get_parameter_from_edb()