pyedb 0.38.0__py3-none-any.whl → 0.39.1__py3-none-any.whl

pyedb/__init__.py

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

pyedb/common/nets.py

@@ -1,44 +1,9 @@
 import math
-import os
 import time
 
 from pyedb.generic.constants import CSS4_COLORS
 
 
-def is_notebook():
-    """Check if pyaedt is running in Jupyter or not.
-
-    Returns
-    -------
-    bool
-    """
-    try:
-        shell = get_ipython().__class__.__name__
-        if shell in ["ZMQInteractiveShell"]:  # pragma: no cover
-            return True  # Jupyter notebook or qtconsole
-        else:
-            return False
-    except NameError:
-        return False  # Probably standard Python interpreter
-
-
-def is_ipython():
-    """Check if pyaedt is running in Jupyter or not.
-
-    Returns
-    -------
-    bool
-    """
-    try:
-        shell = get_ipython().__class__.__name__
-        if shell in ["TerminalInteractiveShell", "SpyderShell"]:
-            return True  # Jupyter notebook or qtconsole
-        else:  # pragma: no cover
-            return False
-    except NameError:
-        return False  # Probably standard Python interpreter
-
-
 class CommonNets:
     def __init__(self, _pedb):
         self._pedb = _pedb
@@ -57,8 +22,6 @@ class CommonNets:
         show=True,
         annotate_component_names=True,
         plot_vias=False,
-        include_outline=True,
-        plot_edges=True,
         **kwargs,
     ):
         """Plot a Net to Matplotlib 2D Chart.
@@ -79,7 +42,7 @@ class CommonNets:
             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
-            Add a customer outline from a list of points of the outline to plot.
+            List of points of the outline to plot.
         size : tuple, int, optional
             Image size in pixel (width, height). Default value is ``(6000, 3000)``
         top_view : bool, optional
@@ -96,17 +59,12 @@ class CommonNets:
             Default is ``False``.
         show : bool, optional
             Whether to show the plot or not. Default is `True`.
-        include_outline : bool, optional
-            Whether to include the internal layout outline or not. Default is `True`.
-        plot_edges : bool, optional
-            Whether to plot polygon edges or not. Default is `True`.
 
         Returns
         -------
         (ax, fig)
             Matplotlib ax and figures.
         """
-
         if "plot_components_on_top" in kwargs and top_view:
             plot_components = kwargs["plot_components_on_top"]
         if "plot_components_on_bottom" in kwargs and not top_view:
@@ -118,30 +76,22 @@ class CommonNets:
                 sign = -1
             return [[sign * i[0], i[1]] for i in poly]
 
-        try:
-            import matplotlib.pyplot as plt
-        except ImportError:  # pragma: no cover
-            self._pedb.logger.error("Matplotlib is needed. Please, install it first.")
-            return False
+        import matplotlib.pyplot as plt
 
         dpi = 100.0
         figsize = (size[0] / dpi, size[1] / dpi)
 
         fig = plt.figure(figsize=figsize)
         ax = fig.add_subplot(1, 1, 1)
-        try:
-            from shapely import affinity, union_all
-            from shapely.geometry import (
-                LinearRing,
-                MultiLineString,
-                MultiPolygon,
-                Point,
-                Polygon,
-            )
-            from shapely.plotting import plot_line, plot_polygon
-        except ImportError:  # pragma: no cover
-            self._pedb.logger.error("Shapely is needed. Please, install it first.")
-            return False
+        from shapely import affinity
+        from shapely.geometry import (
+            LinearRing,
+            MultiLineString,
+            MultiPolygon,
+            Point,
+            Polygon,
+        )
+        from shapely.plotting import plot_line, plot_polygon
 
         start_time = time.time()
         if not nets:
@@ -154,33 +104,19 @@ class CommonNets:
             layers = [layers]
         color_index = 0
         label_colors = {}
-        edge_colors = {}
         if outline:
             poly = Polygon(outline)
             plot_line(poly.boundary, add_points=False, color=(0.7, 0, 0), linewidth=4)
-        elif include_outline:
-            prims = self._pedb.modeler.primitives_by_layer.get("Outline", [])
-            if prims:
-                for prim in prims:
-                    if prim.is_void:
-                        continue
-                    xt, yt = prim.points()
-                    p1 = [(i, j) for i, j in zip(xt[::-1], yt[::-1])]
-                    p1 = mirror_poly(p1)
-                    poly = LinearRing(p1)
-                    plot_line(poly, add_points=False, color=(0.7, 0, 0), linewidth=4)
-            else:
-                bbox = self._pedb.hfss.get_layout_bounding_box()
-                if not bbox:
-                    return False, False
-                x1 = bbox[0]
-                x2 = bbox[2]
-                y1 = bbox[1]
-                y2 = bbox[3]
-                p = [(x1, y1), (x1, y2), (x2, y2), (x2, y1), (x1, y1)]
-                p = mirror_poly(p)
-                poly = LinearRing(p)
-                plot_line(poly, add_points=False, color=(0.7, 0, 0), linewidth=4)
+        else:
+            bbox = self._pedb.hfss.get_layout_bounding_box()
+            x1 = bbox[0]
+            x2 = bbox[2]
+            y1 = bbox[1]
+            y2 = bbox[3]
+            p = [(x1, y1), (x1, y2), (x2, y2), (x2, y1), (x1, y1)]
+            p = mirror_poly(p)
+            poly = LinearRing(p)
+            plot_line(poly, add_points=False, color=(0.7, 0, 0), linewidth=4)
         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]
@@ -310,24 +246,14 @@ class CommonNets:
             #     poly = LineString(line).buffer(prim.width / 2)
             # else:
             xt, yt = prim.points()
-            if len(xt) < 3:
-                return
             p1 = [(i, j) for i, j in zip(xt[::-1], yt[::-1])]
             p1 = mirror_poly(p1)
 
             holes = []
             for void in prim.voids:
                 xvt, yvt = void.points(arc_segments=3)
-                if len(xvt) < 3:
-                    continue
                 h1 = mirror_poly([(i, j) for i, j in zip(xvt, yvt)])
                 holes.append(h1)
-            if len(holes) > 1:
-                holes = union_all([Polygon(i) for i in holes])
-                if isinstance(holes, MultiPolygon):
-                    holes = [i.boundary for i in list(holes.geoms)]
-                else:
-                    holes = [holes.boundary]
             poly = Polygon(p1, holes)
             if layer_name == "Outline":
                 if label_colors[label] in lines:
@@ -338,36 +264,33 @@ class CommonNets:
 
         if color_by_net:
             for net in nets:
-                prims = self._pedb.nets.nets[net].primitives
-                polys = []
-                lines = []
-                if net not in nets:
-                    continue
-                label = "Net " + net
-                label_colors[label] = list(CSS4_COLORS.keys())[color_index]
-                try:
-                    edge_colors[label] = [i * 0.5 for i in label_colors[label]]
-                except TypeError:
-                    edge_colors[label] = label_colors[label]
-                color_index += 1
-                if color_index >= len(CSS4_COLORS):
-                    color_index = 0
-                for prim in prims:
-                    create_poly(prim, polys, lines)
-                if polys:
-                    ob = MultiPolygon(polys)
-                    plot_polygon(
-                        ob,
-                        ax=ax,
-                        color=label_colors[label],
-                        add_points=False,
-                        alpha=0.7,
-                        label=label,
-                        edgecolor="none" if not plot_edges else edge_colors[label],
-                    )
-                if lines:
-                    ob = MultiLineString(p)
-                    plot_line(ob, ax=ax, add_points=False, color=label_colors[label], linewidth=1, label=label)
+                if net in self._pedb.nets.nets:
+                    prims = self._pedb.nets.nets[net].primitives
+                    polys = []
+                    lines = []
+                    if net not in nets:
+                        continue
+                    label = "Net " + net
+                    label_colors[label] = list(CSS4_COLORS.keys())[color_index]
+                    color_index += 1
+                    if color_index >= len(CSS4_COLORS):
+                        color_index = 0
+                    for prim in prims:
+                        create_poly(prim, polys, lines)
+                    if polys:
+                        ob = MultiPolygon(polys)
+                        plot_polygon(
+                            ob,
+                            ax=ax,
+                            color=label_colors[label],
+                            add_points=False,
+                            alpha=0.7,
+                            label=label,
+                            edgecolor="none",
+                        )
+                    if lines:
+                        ob = MultiLineString(p)
+                        plot_line(ob, ax=ax, add_points=False, color=label_colors[label], linewidth=1, label=label)
         else:
             prims_by_layers_dict = {i: j for i, j in self._pedb.modeler.primitives_by_layer.items()}
             if not top_view:
@@ -397,10 +320,6 @@ class CommonNets:
                         if color_index >= len(CSS4_COLORS):
                             color_index = 0
                     label_colors[label] = c
-                    try:
-                        edge_colors[label] = [i * 0.5 for i in c]
-                    except TypeError:
-                        edge_colors[label] = label_colors[label]
                 for prim in prims:
                     create_poly(prim, polys, lines)
                 if polys:
@@ -412,7 +331,7 @@ class CommonNets:
                         add_points=False,
                         alpha=alpha,
                         label=label,
-                        edgecolor="none" if not plot_edges else edge_colors[label],
+                        edgecolor="none",
                     )
                 if lines:
                     ob = MultiLineString(p)
@@ -480,15 +399,10 @@ class CommonNets:
         plt.title(message, size=20)
         if show_legend:
             plt.legend(loc="upper left", fontsize="x-large")
-        end_time = time.time() - start_time
-        self._logger.info(f"Plot Generation time {round(end_time, 3)}")
         if save_plot:
             plt.savefig(save_plot)
-        if show:  # pragma: no cover
-            if is_notebook():
-                pass
-            elif is_ipython() or "PYTEST_CURRENT_TEST" in os.environ:
-                fig.show()
-            else:
-                plt.show()
+        elif show:
+            plt.show()
+        end_time = time.time() - start_time
+        self._logger.info(f"Plot Generation time {round(end_time, 3)}")
         return fig, ax

pyedb/configuration/cfg_components.py

@@ -22,7 +22,7 @@
 import os
 
 from pyedb.configuration.cfg_common import CfgBase
-from pyedb.dotnet.edb_core.general import pascal_to_snake, snake_to_pascal
+from pyedb.dotnet.database.general import pascal_to_snake, snake_to_pascal
 
 
 class CfgComponent(CfgBase):

pyedb/configuration/cfg_general.py

@@ -32,8 +32,10 @@ class CfgGeneral:
         self.suppress_pads = data.get("suppress_pads", True)
 
     def apply(self):
-        self._pedb.design_options.antipads_always_on = self.anti_pads_always_on
-        self._pedb.design_options.suppress_pads = self.suppress_pads
+        # TODO check if design_options features exists in grpc
+        # self._pedb.design_options.antipads_always_on = self.anti_pads_always_on
+        # self._pedb.design_options.suppress_pads = self.suppress_pads
+        pass
 
     def get_data_from_db(self):
         self.anti_pads_always_on = self._pedb.design_options.antipads_always_on

pyedb/configuration/cfg_modeler.py

@@ -22,7 +22,7 @@
 
 from pyedb.configuration.cfg_components import CfgComponent
 from pyedb.configuration.cfg_padstacks import CfgPadstackDefinition, CfgPadstackInstance
-from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstack
+from pyedb.dotnet.database.edb_data.padstacks_data import EDBPadstack
 
 
 class CfgTrace:

pyedb/configuration/cfg_package_definition.py

@@ -21,7 +21,7 @@
 # SOFTWARE.
 
 from pyedb.configuration.cfg_common import CfgBase
-from pyedb.dotnet.edb_core.definition.package_def import PackageDef
+from pyedb.dotnet.database.definition.package_def import PackageDef
 
 
 class CfgPackage(CfgBase):

pyedb/configuration/cfg_padstacks.py

@@ -22,7 +22,7 @@
 import os
 
 from pyedb.configuration.cfg_common import CfgBase
-from pyedb.dotnet.edb_core.general import (
+from pyedb.dotnet.database.general import (
     convert_py_list_to_net_list,
     pascal_to_snake,
     snake_to_pascal,

pyedb/configuration/cfg_ports_sources.py

@@ -24,9 +24,9 @@ import os
 import numpy as np
 
 from pyedb.configuration.cfg_common import CfgBase
-from pyedb.dotnet.edb_core.edb_data.ports import WavePort
-from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
-from pyedb.dotnet.edb_core.geometry.point_data import PointData
+from pyedb.dotnet.database.edb_data.ports import WavePort
+from pyedb.dotnet.database.general import convert_py_list_to_net_list
+from pyedb.dotnet.database.geometry.point_data import PointData
 
 
 class CfgTerminalInfo(CfgBase):
@@ -34,10 +34,24 @@ class CfgTerminalInfo(CfgBase):
 
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb
-        self.type = list(kwargs.keys())[0]
+        if "pin" in kwargs:
+            self.type = "pin"
+        elif "net" in kwargs:
+            self.type = "net"
+        elif "pin_group" in kwargs:
+            self.type = "pin_group"
+        elif "nearest_pin" in kwargs:
+            self.type = "nearest_pin"
+        elif "coordinates" in kwargs:
+            self.type = "coordinates"
+        else:  # pragma no cover
+            raise RuntimeError
         self.value = kwargs[self.type]
+        self.reference_designator = kwargs.get("reference_designator")
+
         self.contact_type = kwargs.get("contact_type", "default")  # options are full, center, quad, inline
-        self.contact_radius = self._pedb.edb_value(kwargs.get("contact_radius", "0.1mm")).ToDouble()
+        contact_radius = "0.1mm" if kwargs.get("contact_radius") is None else kwargs.get("contact_radius")
+        self.contact_radius = self._pedb.edb_value(contact_radius).ToDouble()
         self.num_of_contact = kwargs.get("num_of_contact", 4)
 
     def export_properties(self):
@@ -235,6 +249,8 @@ class CfgCircuitElement(CfgBase):
             self.positive_terminal_info = CfgCoordianteTerminalInfo(self._pedb, **pos)
         else:
             self.positive_terminal_info = CfgTerminalInfo(self._pedb, **pos)
+            if not self.positive_terminal_info.reference_designator:
+                self.positive_terminal_info.reference_designator = self.reference_designator
 
         neg = kwargs.get("negative_terminal", {})
         if len(neg) == 0:
@@ -245,6 +261,8 @@ class CfgCircuitElement(CfgBase):
             self.negative_terminal_info = CfgNearestPinTerminalInfo(self._pedb, **neg)
         else:
             self.negative_terminal_info = CfgTerminalInfo(self._pedb, **neg)
+            if not self.negative_terminal_info.reference_designator:
+                self.negative_terminal_info.reference_designator = self.positive_terminal_info.reference_designator
 
     def create_terminals(self):
         """Create step 1. Collect positive and negative terminals."""
@@ -254,17 +272,23 @@ class CfgCircuitElement(CfgBase):
         pos_objs = dict()
         pos_coor_terminal = dict()
         if self.type == "coax":
-            pins = self._get_pins(pos_type, pos_value)
-            pins = {f"{self.name}_{self.reference_designator}": i for _, i in pins.items()}
+            pins = self._get_pins(pos_type, pos_value, self.positive_terminal_info.reference_designator)
+            pins = {f"{self.name}_{self.positive_terminal_info.reference_designator}": i for _, i in pins.items()}
             pos_objs.update(pins)
         elif pos_type == "coordinates":
             layer = self.positive_terminal_info.layer
             point = [self.positive_terminal_info.point_x, self.positive_terminal_info.point_y]
             net_name = self.positive_terminal_info.net
+            if net_name not in self._pedb.nets:
+                self._pedb.nets.find_or_create_net(net_name)
             pos_coor_terminal[self.name] = self._pedb.get_point_terminal(self.name, net_name, point, layer)
 
         elif pos_type == "pin":
-            pins = {pos_value: self._pedb.components.instances[self.reference_designator].pins[pos_value]}
+            pins = {
+                pos_value: self._pedb.components.instances[self.positive_terminal_info.reference_designator].pins[
+                    pos_value
+                ]
+            }
             if self.positive_terminal_info.contact_type in ["quad", "inline"]:
                 for _, pin in pins.items():
                     contact_type = self.positive_terminal_info.contact_type
@@ -276,7 +300,7 @@ class CfgCircuitElement(CfgBase):
             else:
                 pos_objs.update(pins)
         elif pos_type == "pin_group":
-            pins = self._get_pins(pos_type, pos_value)
+            pins = self._get_pins(pos_type, pos_value, self.positive_terminal_info.reference_designator)
             if self.distributed:
                 pos_objs.update(pins)
                 self._elem_num = len(pos_objs)
@@ -291,7 +315,7 @@ class CfgCircuitElement(CfgBase):
             else:
                 pos_objs[pos_value] = self._pedb.siwave.pin_groups[pos_value]
         elif pos_type == "net":
-            pins = self._get_pins(pos_type, pos_value)
+            pins = self._get_pins(pos_type, pos_value, self.positive_terminal_info.reference_designator)
             if self.distributed:
                 pos_objs.update(pins)
                 self._elem_num = len(pos_objs)
@@ -305,7 +329,7 @@ class CfgCircuitElement(CfgBase):
                     self._elem_num = len(pos_objs)
             else:
                 # create pin group
-                neg_obj = self._create_pin_group(pins)
+                neg_obj = self._create_pin_group(pins, self.positive_terminal_info.reference_designator)
                 pos_objs.update(neg_obj)
         else:
             raise Exception(f"Wrong positive terminal type {pos_type}.")
@@ -322,6 +346,8 @@ class CfgCircuitElement(CfgBase):
                 layer = self.negative_terminal_info.layer
                 point = [self.negative_terminal_info.point_x, self.negative_terminal_info.point_y]
                 net_name = self.negative_terminal_info.net
+                if net_name not in self._pedb.nets:
+                    self._pedb.nets.find_or_create_net(net_name)
                 self.neg_terminal = self._pedb.get_point_terminal(self.name + "_ref", net_name, point, layer)
             elif neg_type == "nearest_pin":
                 ref_net = neg_value.get("reference_net", "GND")
@@ -337,13 +363,17 @@ class CfgCircuitElement(CfgBase):
                     neg_obj = {neg_value: self._pedb.siwave.pin_groups[neg_value]}
                 elif neg_type == "net":
                     # Get pins
-                    pins = self._get_pins(neg_type, neg_value)  # terminal type pin or net
+                    pins = self._get_pins(
+                        neg_type, neg_value, self.negative_terminal_info.reference_designator
+                    )  # terminal type pin or net
                     # create pin group
-                    neg_obj = self._create_pin_group(pins, True)
+                    neg_obj = self._create_pin_group(pins, self.negative_terminal_info.reference_designator, True)
                 elif neg_type == "pin":
-                    terminal_name = f"{self.reference_designator}_{neg_value}"
+                    terminal_name = f"{self.negative_terminal_info.reference_designator}_{neg_value}"
                     neg_obj = {
-                        terminal_name: self._pedb.components.instances[self.reference_designator].pins[neg_value]
+                        terminal_name: self._pedb.components.instances[
+                            self.negative_terminal_info.reference_designator
+                        ].pins[neg_value]
                     }
                 else:
                     raise Exception(f"Wrong negative terminal type {neg_type}.")
@@ -351,11 +381,11 @@ class CfgCircuitElement(CfgBase):
                     j.create_terminal(i) if not j.terminal else j.terminal for i, j in neg_obj.items()
                 ][0]
 
-    def _get_pins(self, terminal_type, terminal_value):
+    def _get_pins(self, terminal_type, terminal_value, reference_designator):
         terminal_value = terminal_value if isinstance(terminal_value, list) else [terminal_value]
 
         def get_pin_obj(pin_name):
-            return {pin_name: self._pedb.components.instances[self.reference_designator].pins[pin_name]}
+            return {pin_name: self._pedb.components.instances[reference_designator].pins[pin_name]}
 
         pins = dict()
         if terminal_type == "pin":
@@ -363,11 +393,11 @@ class CfgCircuitElement(CfgBase):
                 pins.update(get_pin_obj(i))
         else:
             if terminal_type == "net":
-                temp = self._pedb.components.get_pins(self.reference_designator, terminal_value[0])
+                temp = self._pedb.components.get_pins(reference_designator, terminal_value[0])
             elif terminal_type == "pin_group":
                 pin_group = self._pedb.siwave.pin_groups[terminal_value[0]]
                 temp = pin_group.pins
-            pins.update({f"{self.reference_designator}_{terminal_value[0]}_{i}": j for i, j in temp.items()})
+            pins.update({f"{reference_designator}_{terminal_value[0]}_{i}": j for i, j in temp.items()})
         return pins
 
     def _create_virtual_pins_on_pin(self, pin, contact_type, radius, num_of_contact=4):
@@ -428,15 +458,18 @@ class CfgCircuitElement(CfgBase):
                 is_pin=True,
             )
             instances[pin_name] = p_inst
+        self._pedb.components.create(
+            pins=list(instances.values()),
+        )
         return instances
 
-    def _create_pin_group(self, pins, is_ref=False):
+    def _create_pin_group(self, pins, reference_designator, is_ref=False):
         if is_ref:
-            pg_name = f"pg_{self.name}_{self.reference_designator}_ref"
+            pg_name = f"pg_{self.name}_{reference_designator}_ref"
         else:
-            pg_name = f"pg_{self.name}_{self.reference_designator}"
+            pg_name = f"pg_{self.name}_{reference_designator}"
         pin_names = [i.component_pin for i in pins.values()]
-        name, temp = self._pedb.siwave.create_pin_group(self.reference_designator, pin_names, pg_name)
+        name, temp = self._pedb.siwave.create_pin_group(reference_designator, pin_names, pg_name)
         return {name: temp}
 
 

pyedb/configuration/configuration.py

@@ -27,7 +27,7 @@ from pathlib import Path
 import toml
 
 from pyedb.configuration.cfg_data import CfgData
-from pyedb.dotnet.edb_core.definition.package_def import PackageDef
+from pyedb.dotnet.database.definition.package_def import PackageDef
 
 
 class Configuration:
@@ -146,7 +146,24 @@ class Configuration:
             for cfg_pdef in temp:
                 cfg_pdef.api.set_parameters_to_edb()
         else:
+            temp_pdef_data = {}
+            for pdef_name, pdef in self._pedb.padstacks.definitions.items():
+                pdef_data = pdef._padstack_def_data
+                for lyr_name in list(pdef_data.GetLayerNames()):
+                    result = pdef_data.GetPadParametersValue(lyr_name, self._pedb._edb.Definition.PadType.RegularPad)
+                    flag, pad_shape, params, offset_x, offset_y, rotation = result
+                    if flag is False:
+                        result = pdef_data.GetPolygonalPadParameters(
+                            lyr_name, self._pedb._edb.Definition.PadType.RegularPad
+                        )
+                        flag, polygon_data, offset_x, offset_y, rotation = result
+                        if flag:
+                            temp_pdef_data[pdef_name] = pdef_data
+                            break
             self.cfg_data.stackup.apply()
+            for pdef_name, pdef_data in temp_pdef_data.items():
+                pdef = self._pedb.padstacks.definitions[pdef_name]
+                pdef._padstack_def_data = pdef_data
 
         # Configure padstacks
         if self.cfg_data.padstacks: