pyedb 0.31.0__py3-none-any.whl → 0.34.1__py3-none-any.whl

pyedb/dotnet/edb_core/materials.py

@@ -69,6 +69,7 @@ DC_ATTRIBUTES = [
     "dc_conductivity",
     "dc_permittivity",
 ]
+PERMEABILITY_DEFAULT_VALUE = 1
 
 
 def get_line_float_value(line):
@@ -114,7 +115,6 @@ class Material(object):
         self.__name: str = material_def.GetName()
         self.__material_def = material_def
         self.__dc_model = material_def.GetDielectricMaterialModel()
-        self.__properties: MaterialProperties = MaterialProperties()
 
     @property
     def name(self):
@@ -130,8 +130,7 @@ class Material(object):
     def conductivity(self):
         """Get material conductivity."""
         material_property_id = self.__edb_definition.MaterialPropertyId.Conductivity
-        self.__properties.conductivity = self.__property_value(material_property_id)
-        return self.__properties.conductivity
+        return self.__property_value(material_property_id)
 
     @conductivity.setter
     def conductivity(self, value):
@@ -144,8 +143,7 @@ class Material(object):
     def permittivity(self):
         """Get material permittivity."""
         material_property_id = self.__edb_definition.MaterialPropertyId.Permittivity
-        self.__properties.permittivity = self.__property_value(material_property_id)
-        return self.__properties.permittivity
+        return self.__property_value(material_property_id)
 
     @permittivity.setter
     def permittivity(self, value):
@@ -158,8 +156,7 @@ class Material(object):
     def permeability(self):
         """Get material permeability."""
         material_property_id = self.__edb_definition.MaterialPropertyId.Permeability
-        self.__properties.permeability = self.__property_value(material_property_id)
-        return self.__properties.permeability
+        return self.__property_value(material_property_id)
 
     @permeability.setter
     def permeability(self, value):
@@ -182,8 +179,7 @@ class Material(object):
     def dielectric_loss_tangent(self):
         """Get material loss tangent."""
         material_property_id = self.__edb_definition.MaterialPropertyId.DielectricLossTangent
-        self.__properties.dielectric_loss_tangent = self.__property_value(material_property_id)
-        return self.__properties.dielectric_loss_tangent
+        return self.__property_value(material_property_id)
 
     @loss_tangent.setter
     def loss_tangent(self, value):
@@ -205,9 +201,10 @@ class Material(object):
     @property
     def dc_conductivity(self):
         """Get material dielectric conductivity."""
+        res = None
         if self.__dc_model:
-            self.__properties.dc_conductivity = self.__dc_model.GetDCConductivity()
-        return self.__properties.dc_conductivity
+            res = self.__dc_model.GetDCConductivity()
+        return res
 
     @dc_conductivity.setter
     def dc_conductivity(self, value: Union[int, float]):
@@ -220,9 +217,10 @@ class Material(object):
     @property
     def dc_permittivity(self):
         """Get material dielectric relative permittivity"""
+        res = None
         if self.__dc_model:
-            self.__properties.dc_permittivity = self.__dc_model.GetDCRelativePermitivity()
-        return self.__properties.dc_permittivity
+            res = self.__dc_model.GetDCRelativePermitivity()
+        return res
 
     @dc_permittivity.setter
     def dc_permittivity(self, value: Union[int, float]):
@@ -237,9 +235,10 @@ class Material(object):
     @property
     def dielectric_model_frequency(self):
         """Get material frequency in GHz."""
+        res = None
         if self.__dc_model:
-            self.__properties.dielectric_model_frequency = self.__dc_model.GetFrequency()
-        return self.__properties.dielectric_model_frequency
+            res = self.__dc_model.GetFrequency()
+        return res
 
     @dielectric_model_frequency.setter
     def dielectric_model_frequency(self, value: Union[int, float]):
@@ -252,9 +251,10 @@ class Material(object):
     @property
     def loss_tangent_at_frequency(self):
         """Get material loss tangeat at frequency."""
+        res = None
         if self.__dc_model:
-            self.__properties.loss_tangent_at_frequency = self.__dc_model.GetLossTangentAtFrequency()
-        return self.__properties.loss_tangent_at_frequency
+            res = self.__dc_model.GetLossTangentAtFrequency()
+        return res
 
     @loss_tangent_at_frequency.setter
     def loss_tangent_at_frequency(self, value):
@@ -268,9 +268,10 @@ class Material(object):
     @property
     def permittivity_at_frequency(self):
         """Get material relative permittivity at frequency."""
+        res = None
         if self.__dc_model:
-            self.__properties.permittivity_at_frequency = self.__dc_model.GetRelativePermitivityAtFrequency()
-        return self.__properties.permittivity_at_frequency
+            res = self.__dc_model.GetRelativePermitivityAtFrequency()
+        return res
 
     @permittivity_at_frequency.setter
     def permittivity_at_frequency(self, value: Union[int, float]):
@@ -284,8 +285,7 @@ class Material(object):
     def magnetic_loss_tangent(self):
         """Get material magnetic loss tangent."""
         material_property_id = self.__edb_definition.MaterialPropertyId.MagneticLossTangent
-        self.__properties.magnetic_loss_tangent = self.__property_value(material_property_id)
-        return self.__properties.magnetic_loss_tangent
+        return self.__property_value(material_property_id)
 
     @magnetic_loss_tangent.setter
     def magnetic_loss_tangent(self, value):
@@ -298,8 +298,7 @@ class Material(object):
     def thermal_conductivity(self):
         """Get material thermal conductivity."""
         material_property_id = self.__edb_definition.MaterialPropertyId.ThermalConductivity
-        self.__properties.thermal_conductivity = self.__property_value(material_property_id)
-        return self.__properties.thermal_conductivity
+        return self.__property_value(material_property_id)
 
     @thermal_conductivity.setter
     def thermal_conductivity(self, value):
@@ -312,8 +311,7 @@ class Material(object):
     def mass_density(self):
         """Get material mass density."""
         material_property_id = self.__edb_definition.MaterialPropertyId.MassDensity
-        self.__properties.mass_density = self.__property_value(material_property_id)
-        return self.__properties.mass_density
+        return self.__property_value(material_property_id)
 
     @mass_density.setter
     def mass_density(self, value):
@@ -326,8 +324,7 @@ class Material(object):
     def youngs_modulus(self):
         """Get material youngs modulus."""
         material_property_id = self.__edb_definition.MaterialPropertyId.YoungsModulus
-        self.__properties.youngs_modulus = self.__property_value(material_property_id)
-        return self.__properties.youngs_modulus
+        return self.__property_value(material_property_id)
 
     @youngs_modulus.setter
     def youngs_modulus(self, value):
@@ -340,8 +337,7 @@ class Material(object):
     def specific_heat(self):
         """Get material specific heat."""
         material_property_id = self.__edb_definition.MaterialPropertyId.SpecificHeat
-        self.__properties.specific_heat = self.__property_value(material_property_id)
-        return self.__properties.specific_heat
+        return self.__property_value(material_property_id)
 
     @specific_heat.setter
     def specific_heat(self, value):
@@ -354,8 +350,7 @@ class Material(object):
     def poisson_ratio(self):
         """Get material poisson ratio."""
         material_property_id = self.__edb_definition.MaterialPropertyId.PoissonsRatio
-        self.__properties.poisson_ratio = self.__property_value(material_property_id)
-        return self.__properties.poisson_ratio
+        return self.__property_value(material_property_id)
 
     @poisson_ratio.setter
     def poisson_ratio(self, value):
@@ -368,8 +363,7 @@ class Material(object):
     def thermal_expansion_coefficient(self):
         """Get material thermal coefficient."""
         material_property_id = self.__edb_definition.MaterialPropertyId.ThermalExpansionCoefficient
-        self.__properties.thermal_expansion_coefficient = self.__property_value(material_property_id)
-        return self.__properties.thermal_expansion_coefficient
+        return self.__property_value(material_property_id)
 
     @thermal_expansion_coefficient.setter
     def thermal_expansion_coefficient(self, value):
@@ -380,10 +374,10 @@ class Material(object):
 
     def to_dict(self):
         """Convert material into dictionary."""
-        self.__load_all_properties()
+        properties = self.__load_all_properties()
 
         res = {"name": self.name}
-        res.update(self.__properties.model_dump())
+        res.update(properties.model_dump())
         return res
 
     def update(self, input_dict: dict):
@@ -419,10 +413,13 @@ class Material(object):
         """
         return self.__edb.edb_value(value)
 
-    def __load_all_properties(self):
+    def __load_all_properties(self) -> MaterialProperties:
         """Load all properties of the material."""
-        for property in self.__properties.model_dump().keys():
-            _ = getattr(self, property)
+        res = MaterialProperties()
+        for property in res.model_dump().keys():
+            value = getattr(self, property)
+            setattr(res, property, value)
+        return res
 
     def __property_value(self, material_property_id):
         """Get property value from a material property id."""
@@ -507,6 +504,9 @@ class Materials(object):
 
         material_def = self.__edb_definition.MaterialDef.Create(self.__edb.active_db, name)
         material = Material(self.__edb, material_def)
+        # Apply default values to the material
+        if "permeability" not in kwargs:
+            kwargs["permeability"] = PERMEABILITY_DEFAULT_VALUE
         attributes_input_dict = {key: val for (key, val) in kwargs.items() if key in ATTRIBUTES + DC_ATTRIBUTES}
         if "loss_tangent" in kwargs:  # pragma: no cover
             warnings.warn(

pyedb/dotnet/edb_core/modeler.py

@@ -188,7 +188,10 @@ class Modeler(object):
         for lay in self._pedb.stackup.non_stackup_layers:
             _primitives_by_layer[lay] = []
         for i in self._layout.primitives:
-            lay = i.layer.name
+            layer = i.layer
+            if not layer:
+                continue
+            lay = layer.name
             if lay in _primitives_by_layer:
                 _primitives_by_layer[lay].append(i)
         return _primitives_by_layer

pyedb/dotnet/edb_core/nets.py

@@ -22,18 +22,15 @@
 
 from __future__ import absolute_import  # noreorder
 
-import os
-import time
 import warnings
 
+from pyedb.common.nets import CommonNets
 from pyedb.dotnet.edb_core.edb_data.nets_data import EDBNetsData
-from pyedb.generic.constants import CSS4_COLORS
 from pyedb.generic.general_methods import generate_unique_name
 from pyedb.misc.utilities import compute_arc_points
-from pyedb.modeler.geometry_operators import GeometryOperators
 
 
-class EdbNets(object):
+class EdbNets(CommonNets):
     """Manages EDB methods for nets management accessible from `Edb.nets` property.
 
     Examples
@@ -381,295 +378,6 @@ class EdbNets(object):
         # fmt: on
         return x, y
 
-    def get_plot_data(
-        self,
-        nets=None,
-        layers=None,
-        color_by_net=False,
-        outline=None,
-        plot_components_on_top=False,
-        plot_components_on_bottom=False,
-    ):
-        """Return List of points for Matplotlib 2D Chart.
-
-        Parameters
-        ----------
-        nets : str, list, optional
-            Name of the net or list of nets to plot. If `None` (default value) all nets will be plotted.
-        layers : str, list, optional
-            Name of the layers to include in the plot. If `None` all the signal layers will be considered.
-        color_by_net : bool, optional
-            If ``True``  the plot will be colored by net.
-            If ``False`` the plot will be colored by layer. (default)
-        outline : list, optional
-            List of points of the outline to plot.
-        plot_components_on_top : bool, optional
-            If ``True``  the components placed on top layer are plotted.
-            If ``False`` the components are not plotted. (default)
-            If nets and/or layers is specified, only the components belonging to the specified nets/layers are plotted.
-        plot_components_on_bottom : bool, optional
-            If ``True``  the components placed on bottom layer are plotted.
-            If ``False`` the components are not plotted. (default)
-            If nets and/or layers is specified, only the components belonging to the specified nets/layers are plotted.
-
-        Returns
-        -------
-        List, str: list of data to be used in plot.
-            In case of remote session it will be returned a string that could be converted \
-            to list using ast.literal_eval().
-        """
-        start_time = time.time()
-        if not nets:
-            nets = list(self.nets.keys())
-        if isinstance(nets, str):
-            nets = [nets]
-        if not layers:
-            layers = list(self._pedb.stackup.signal_layers.keys())
-        if isinstance(layers, str):
-            layers = [layers]
-        color_index = 0
-        objects_lists = []
-        label_colors = {}
-        n_label = 0
-        max_labels = 10
-
-        if outline:
-            xt = [i[0] for i in outline]
-            yt = [i[1] for i in outline]
-            xc, yc = GeometryOperators.orient_polygon(xt, yt, clockwise=True)
-            vertices = [(i, j) for i, j in zip(xc, yc)]
-            codes = [2 for _ in vertices]
-            codes[0] = 1
-            vertices.append((0, 0))
-            codes.append(79)
-            objects_lists.append([vertices, codes, "b", "Outline", 1.0, 1.5, "contour"])
-            n_label += 1
-        layer_colors = {i: k.color for i, k in self._pedb.stackup.layers.items()}
-        top_layer = list(self._pedb.stackup.signal_layers.keys())[0]
-        bottom_layer = list(self._pedb.stackup.signal_layers.keys())[-1]
-        if plot_components_on_top or plot_components_on_bottom:
-            nc = 0
-            for comp in self._pedb.components.instances.values():
-                if not comp.is_enabled:
-                    continue
-                net_names = comp.nets
-                if nets and not any([i in nets for i in net_names]):
-                    continue
-                layer_name = comp.placement_layer
-                if layer_name not in layers:
-                    continue
-                if plot_components_on_top and layer_name == top_layer:
-                    component_color = (184 / 255, 115 / 255, 51 / 255)  # this is the color used in AEDT
-                    label = "Component on top layer"
-                elif plot_components_on_bottom and layer_name == bottom_layer:
-                    component_color = (41 / 255, 171 / 255, 135 / 255)  # 41, 171, 135
-                    label = "Component on bottom layer"
-                else:
-                    continue
-                cbb = comp.bounding_box
-                x = [cbb[0], cbb[0], cbb[2], cbb[2]]
-                y = [cbb[1], cbb[3], cbb[3], cbb[1]]
-                vertices = [(i, j) for i, j in zip(x, y)]
-                codes = [2 for _ in vertices]
-                codes[0] = 1
-                vertices.append((0, 0))
-                codes.append(79)
-                if label not in label_colors:
-                    label_colors[label] = component_color
-                    objects_lists.append([vertices, codes, label_colors[label], label, 1.0, 2.0, "contour"])
-                    n_label += 1
-                else:
-                    objects_lists.append([vertices, codes, label_colors[label], None, 1.0, 2.0, "contour"])
-                nc += 1
-            self._logger.debug("Plotted {} component(s)".format(nc))
-        for prim in self._pedb.modeler.primitives:
-            if prim.is_void:
-                continue
-            net_name = prim.net_name
-            layer_name = prim.layer_name
-            if nets and (net_name not in nets or layer_name not in layers):
-                continue
-            prim_type = prim.primitive_type
-            if prim_type == "path":
-                try:
-                    x, y = prim.points()
-                except ValueError:
-                    x = None
-                if not x:
-                    continue
-                create_label = False
-                if not color_by_net:
-                    label = "Layer " + layer_name
-                    if label not in label_colors:
-                        try:
-                            color = layer_colors[layer_name]
-                            c = (
-                                float(color[0] / 255),
-                                float(color[1] / 255),
-                                float(color[2] / 255),
-                            )
-                        except:
-                            c = list(CSS4_COLORS.keys())[color_index]
-                            color_index += 1
-                            if color_index >= len(CSS4_COLORS):
-                                color_index = 0
-                        label_colors[label] = c
-                        create_label = True
-                else:
-                    label = "Net " + net_name
-                    if label not in label_colors:
-                        label_colors[label] = list(CSS4_COLORS.keys())[color_index]
-                        color_index += 1
-                        if color_index >= len(CSS4_COLORS):
-                            color_index = 0
-                        create_label = True
-
-                if create_label and n_label <= max_labels:
-                    objects_lists.append([x, y, label_colors[label], label, 0.4, "fill"])
-                    n_label += 1
-                else:
-                    objects_lists.append([x, y, label_colors[label], None, 0.4, "fill"])
-            elif prim_type == "polygon":
-                xt, yt = prim.points()
-                if not xt:
-                    continue
-                x, y = GeometryOperators.orient_polygon(xt, yt, clockwise=True)
-                vertices = [(i, j) for i, j in zip(x, y)]
-                codes = [2 for _ in vertices]
-                codes[0] = 1
-                vertices.append((0, 0))
-                codes.append(79)
-
-                for void in prim.voids:
-                    xvt, yvt = void.points()
-                    if xvt:
-                        xv, yv = GeometryOperators.orient_polygon(xvt, yvt, clockwise=False)
-                        tmpV = [(i, j) for i, j in zip(xv, yv)]
-                        vertices.extend(tmpV)
-                        tmpC = [2 for _ in tmpV]
-                        tmpC[0] = 1
-                        codes.extend(tmpC)
-                        vertices.append((0, 0))
-                        codes.append(79)
-
-                create_label = False
-                if not color_by_net:
-                    label = "Layer " + layer_name
-                    if label not in label_colors:
-                        try:
-                            color = layer_colors[layer_name]
-                            c = (
-                                float(color[0] / 255),
-                                float(color[1] / 255),
-                                float(color[2] / 255),
-                            )
-                        except:
-                            c = list(CSS4_COLORS.keys())[color_index]
-                            color_index += 1
-                            if color_index >= len(CSS4_COLORS):
-                                color_index = 0
-                        label_colors[label] = c
-                        create_label = True
-                else:
-                    label = "Net " + net_name
-                    if label not in label_colors:
-                        label_colors[label] = list(CSS4_COLORS.keys())[color_index]
-                        color_index += 1
-                        if color_index >= len(CSS4_COLORS):
-                            color_index = 0
-                        create_label = True
-
-                if create_label and n_label <= max_labels:
-                    if layer_name == "Outline":
-                        objects_lists.append([vertices, codes, label_colors[label], label, 1.0, 2.0, "contour"])
-                    else:
-                        objects_lists.append([vertices, codes, label_colors[label], label, 0.4, "path"])
-                    n_label += 1
-                else:
-                    if layer_name == "Outline":
-                        objects_lists.append([vertices, codes, label_colors[label], None, 1.0, 2.0, "contour"])
-                    else:
-                        objects_lists.append([vertices, codes, label_colors[label], None, 0.4, "path"])
-            elif prim_type == "circle":
-                x, y = prim.points()
-                if not x:
-                    continue
-                create_label = False
-                if not color_by_net:
-                    label = "Layer " + layer_name
-                    if label not in label_colors:
-                        try:
-                            color = layer_colors[layer_name]
-                            c = (
-                                float(color[0] / 255),
-                                float(color[1] / 255),
-                                float(color[2] / 255),
-                            )
-                        except:
-                            c = list(CSS4_COLORS.keys())[color_index]
-                            color_index += 1
-                            if color_index >= len(CSS4_COLORS):
-                                color_index = 0
-                        label_colors[label] = c
-                        create_label = True
-                else:
-                    label = "Net " + net_name
-                    if label not in label_colors:
-                        label_colors[label] = list(CSS4_COLORS.keys())[color_index]
-                        color_index += 1
-                        if color_index >= len(CSS4_COLORS):
-                            color_index = 0
-                        create_label = True
-
-                if create_label and n_label <= max_labels:
-                    objects_lists.append([x, y, label_colors[label], label, 0.4, "fill"])
-                    n_label += 1
-                else:
-                    objects_lists.append([x, y, label_colors[label], None, 0.4, "fill"])
-            elif prim_type == "rectangle":
-                x, y = prim.points()
-                if not x:
-                    continue
-                create_label = False
-                if not color_by_net:
-                    label = "Layer " + layer_name
-                    if label not in label_colors:
-                        try:
-                            color = layer_colors[layer_name]
-                            c = (
-                                float(color[0] / 255),
-                                float(color[1] / 255),
-                                float(color[2] / 255),
-                            )
-                        except:
-                            c = list(CSS4_COLORS.keys())[color_index]
-                            color_index += 1
-                            if color_index >= len(CSS4_COLORS):
-                                color_index = 0
-                        label_colors[label] = c
-                        create_label = True
-                else:
-                    label = "Net " + net_name
-                    if label not in label_colors:
-                        label_colors[label] = list(CSS4_COLORS.keys())[color_index]
-                        color_index += 1
-                        if color_index >= len(CSS4_COLORS):
-                            color_index = 0
-                        create_label = True
-
-                if create_label and n_label <= max_labels:
-                    objects_lists.append([x, y, label_colors[label], label, 0.4, "fill"])
-                    n_label += 1
-                else:
-                    objects_lists.append([x, y, label_colors[label], None, 0.4, "fill"])
-
-        end_time = time.time() - start_time
-        self._logger.info("Nets Point Generation time %s seconds", round(end_time, 3))
-        if os.getenv("PYAEDT_SERVER_AEDT_PATH", None):
-            return str(objects_lists)
-        else:
-            return objects_lists
-
     def classify_nets(self, power_nets=None, signal_nets=None):
         """Reassign power/ground or signal nets based on list of nets.
 
@@ -701,85 +409,6 @@ class EdbNets(object):
                 self.nets[net].net_object.SetIsPowerGround(False)
         return True
 
-    def plot(
-        self,
-        nets=None,
-        layers=None,
-        color_by_net=False,
-        show_legend=True,
-        save_plot=None,
-        outline=None,
-        size=(2000, 1000),
-        plot_components_on_top=False,
-        plot_components_on_bottom=False,
-        show=True,
-        title=None,
-    ):
-        """Plot a Net to Matplotlib 2D Chart.
-
-        Parameters
-        ----------
-        nets : str, list, optional
-            Name of the net or list of nets to plot. If ``None`` all nets will be plotted.
-        layers : str, list, optional
-            Name of the layers to include in the plot. If ``None`` all the signal layers will be considered.
-        color_by_net : bool, optional
-            If ``True``  the plot will be colored by net.
-            If ``False`` the plot will be colored by layer. (default)
-        show_legend : bool, optional
-            If ``True`` the legend is shown in the plot. (default)
-            If ``False`` the legend is not shown.
-        save_plot : str, optional
-            If a path is specified the plot will be saved in this location.
-            If ``save_plot`` is provided, the ``show`` parameter is ignored.
-        outline : list, optional
-            List of points of the outline to plot.
-        size : tuple, int, optional
-            Image size in pixel (width, height). Default value is ``(2000, 1000)``
-        plot_components_on_top : bool, optional
-            If ``True``  the components placed on top layer are plotted.
-            If ``False`` the components are not plotted. (default)
-            If nets and/or layers is specified, only the components belonging to the specified nets/layers are plotted.
-        plot_components_on_bottom : bool, optional
-            If ``True``  the components placed on bottom layer are plotted.
-            If ``False`` the components are not plotted. (default)
-            If nets and/or layers is specified, only the components belonging to the specified nets/layers are plotted.
-        show : bool, optional
-            Whether to show the plot or not. Default is `True`.
-        """
-        from pyedb.generic.plot import plot_matplotlib
-
-        object_lists = self.get_plot_data(
-            nets,
-            layers,
-            color_by_net,
-            outline,
-            plot_components_on_top,
-            plot_components_on_bottom,
-        )
-
-        if isinstance(size, int):  # pragma: no cover
-            board_size_x, board_size_y = self._pedb.get_statistics().layout_size
-            fig_size_x = size
-            fig_size_y = board_size_y * fig_size_x / board_size_x
-            size = (fig_size_x, fig_size_y)
-
-        plot_title = title
-        if plot_title is None:
-            plot_title = self._pedb.active_cell.GetName()
-
-        return plot_matplotlib(
-            plot_data=object_lists,
-            size=size,
-            show_legend=show_legend,
-            xlabel="X (m)",
-            ylabel="Y (m)",
-            title=plot_title,
-            save_plot=save_plot,
-            axis_equal=True,
-            show=show,
-        )
-
     def is_power_gound_net(self, netname_list):
         """Determine if one of the  nets in a list is power or ground.
 

pyedb/generic/filesystem.py

@@ -116,13 +116,10 @@ class Scratch:
         -------
 
         """
-        from distutils.dir_util import copy_tree
 
-        if destfolder:
-            copy_tree(src_folder, destfolder)
-        else:
+        if not destfolder:
             destfolder = os.path.join(self.path, os.path.split(src_folder)[-1])
-            copy_tree(src_folder, destfolder)
+        shutil.copytree(src_folder, destfolder, dirs_exist_ok=True)
         return destfolder
 
     def __enter__(self):