pyedb 0.22.1__py3-none-any.whl → 0.24.0__py3-none-any.whl

pyedb/__init__.py

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

pyedb/configuration/cfg_components.py

@@ -155,7 +155,7 @@ class CfgComponents:
     def _load_data_from_db(self):
         self.components = []
         comps_in_db = self._pedb.components
-        for _, comp in comps_in_db.components.items():
+        for _, comp in comps_in_db.instances.items():
             cfg_comp = CfgComponent(
                 enabled=comp.enabled,
                 reference_designator=comp.name,

pyedb/configuration/cfg_ports_sources.py

@@ -228,7 +228,7 @@ class CfgCircuitElement(CfgBase):
                 neg_obj = self._create_pin_group(pins)
                 pos_objs.update(neg_obj)
         elif pos_type == "pin":
-            pins = {pos_value: self._pedb.components.components[self.reference_designator].pins[pos_value]}
+            pins = {pos_value: self._pedb.components.instances[self.reference_designator].pins[pos_value]}
             pos_objs.update(pins)
         else:
             raise f"Wrong positive terminal type {pos_type}"
@@ -263,7 +263,7 @@ class CfgCircuitElement(CfgBase):
                     # create pin group
                     neg_obj = self._create_pin_group(pins, True)
                 elif neg_type == "pin":
-                    neg_obj = {neg_value: self._pedb.components.components[self.reference_designator].pins[neg_value]}
+                    neg_obj = {neg_value: self._pedb.components.instances[self.reference_designator].pins[neg_value]}
                 else:
                     raise f"Wrong negative terminal type {neg_type}"
                 self.neg_terminal = [
@@ -274,7 +274,7 @@ class CfgCircuitElement(CfgBase):
         terminal_value = terminal_value if isinstance(terminal_value, list) else [terminal_value]
 
         def get_pin_obj(pin_name):
-            return {pin_name: self._pedb.components.components[self.reference_designator].pins[pin_name]}
+            return {pin_name: self._pedb.components.instances[self.reference_designator].pins[pin_name]}
 
         pins = dict()
         if terminal_type == "pin":

pyedb/configuration/configuration.py

@@ -35,7 +35,7 @@ class Configuration:
 
     def __init__(self, pedb):
         self._pedb = pedb
-        self._components = self._pedb.components.components
+        self._components = self._pedb.components.instances
         self.data = {}
         self._s_parameter_library = ""
         self._spice_model_library = ""
@@ -210,7 +210,7 @@ class Configuration:
 
     def _load_package_def(self):
         """Imports package definition information from JSON."""
-        comps = self._pedb.components.components
+        comps = self._pedb.components.instances
         for pkgd in self.data["package_definitions"]:
             name = pkgd["name"]
             if name in self._pedb.definitions.package:

pyedb/dotnet/edb.py

@@ -454,13 +454,13 @@ class Edb(Database):
     @property
     def excitations(self):
         """Get all layout excitations."""
-        terms = [term for term in self.layout.terminals if int(term.GetBoundaryType()) == 0]
+        terms = [term for term in self.layout.terminals if int(term._edb_object.GetBoundaryType()) == 0]
         temp = {}
         for ter in terms:
-            if "BundleTerminal" in ter.GetType().ToString():
-                temp[ter.GetName()] = BundleWavePort(self, ter)
+            if "BundleTerminal" in ter._edb_object.GetType().ToString():
+                temp[ter.name] = BundleWavePort(self, ter._edb_object)
             else:
-                temp[ter.GetName()] = GapPort(self, ter)
+                temp[ter.name] = GapPort(self, ter._edb_object)
         return temp
 
     @property
@@ -473,41 +473,41 @@ class Edb(Database):
                    :class:`pyedb.dotnet.edb_core.edb_data.ports.WavePort`,]]
 
         """
-        temp = [term for term in self.layout.terminals if not term.IsReferenceTerminal()]
+        temp = [term for term in self.layout.terminals if not term.is_reference_terminal]
 
         ports = {}
         for t in temp:
-            t2 = Terminal(self, t)
+            t2 = Terminal(self, t._edb_object)
             if not t2.boundary_type == "PortBoundary":
                 continue
 
             if t2.is_circuit_port:
-                port = CircuitPort(self, t)
+                port = CircuitPort(self, t._edb_object)
                 ports[port.name] = port
             elif t2.terminal_type == "BundleTerminal":
-                port = BundleWavePort(self, t)
+                port = BundleWavePort(self, t._edb_object)
                 ports[port.name] = port
             elif t2.hfss_type == "Wave":
-                ports[t2.name] = WavePort(self, t)
+                ports[t2.name] = WavePort(self, t._edb_object)
             elif t2.terminal_type == "PadstackInstanceTerminal":
-                ports[t2.name] = CoaxPort(self, t)
+                ports[t2.name] = CoaxPort(self, t._edb_object)
             else:
-                ports[t2.name] = GapPort(self, t)
+                ports[t2.name] = GapPort(self, t._edb_object)
         return ports
 
     @property
     def excitations_nets(self):
         """Get all excitations net names."""
-        names = list(set([i.GetNet().GetName() for i in self.layout.terminals]))
+        names = list(set([i.net.name for i in self.layout.terminals]))
         names = [i for i in names if i]
         return names
 
     @property
     def sources(self):
         """Get all layout sources."""
-        terms = [term for term in self.layout.terminals if int(term.GetBoundaryType()) in [3, 4, 7]]
-        terms = [term for term in terms if not term.IsReferenceTerminal()]
-        return {ter.GetName(): ExcitationSources(self, ter) for ter in terms}
+        terms = [term for term in self.layout.terminals if int(term._edb_object.GetBoundaryType()) in [3, 4, 7]]
+        terms = [term for term in terms if not term._edb_object.IsReferenceTerminal()]
+        return {ter.name: ExcitationSources(self, ter._edb_object) for ter in terms}
 
     @property
     def voltage_regulator_modules(self):
@@ -1167,9 +1167,9 @@ class Edb(Database):
             elif obj_type == LayoutObjType.Primitive.name:
                 prim_type = i.GetPrimitiveType().ToString()
                 if prim_type == Primitives.Path.name:
-                    from pyedb.dotnet.edb_core.edb_data.primitives_data import EdbPath
+                    from pyedb.dotnet.edb_core.cell.primitive.path import Path
 
-                    temp.append(EdbPath(i, self))
+                    temp.append(Path(self, i))
                 elif prim_type == Primitives.Rectangle.name:
                     from pyedb.dotnet.edb_core.edb_data.primitives_data import (
                         EdbRectangle,
@@ -1669,11 +1669,11 @@ class Edb(Database):
         from pyedb.dotnet.clr_module import Tuple
 
         _polys = []
-        terms = [term for term in self.layout.terminals if int(term.GetBoundaryType()) in [0, 3, 4, 7, 8]]
+        terms = [term for term in self.layout.terminals if int(term._edb_object.GetBoundaryType()) in [0, 3, 4, 7, 8]]
         locations = []
         for term in terms:
-            if term.GetTerminalType().ToString() == "PointTerminal" and term.GetNet().GetName() in reference_list:
-                pd = term.GetParameters()[1]
+            if term._edb_object.GetTerminalType().ToString() == "PointTerminal" and term.net.name in reference_list:
+                pd = term._edb_object.GetParameters()[1]
                 locations.append([pd.X.ToDouble(), pd.Y.ToDouble()])
         for point in locations:
             pointA = self.edb_api.geometry.point_data(
@@ -2214,11 +2214,13 @@ class Edb(Database):
                     if pin.pingroups:
                         pins_to_preserve.append(pin.id)
         if check_terminals:
-            terms = [term for term in self.layout.terminals if int(term.GetBoundaryType()) in [0, 3, 4, 7, 8]]
+            terms = [
+                term for term in self.layout.terminals if int(term._edb_object.GetBoundaryType()) in [0, 3, 4, 7, 8]
+            ]
             for term in terms:
-                if term.GetTerminalType().ToString() == "PadstackInstanceTerminal":
-                    if term.GetParameters()[1].GetNet().GetName() in reference_list:
-                        pins_to_preserve.append(term.GetParameters()[1].GetId())
+                if term._edb_object.GetTerminalType().ToString() == "PadstackInstanceTerminal":
+                    if term._edb_object.GetParameters()[1].GetNet().GetName() in reference_list:
+                        pins_to_preserve.append(term._edb_object.GetParameters()[1].GetId())
 
         for i in self.nets.nets.values():
             name = i.name
@@ -2309,7 +2311,7 @@ class Edb(Database):
             return poly.Subtract(convert_py_list_to_net_list(poly), convert_py_list_to_net_list(voids))
 
         def clip_path(path):
-            pdata = path.polygon_data.edb_api
+            pdata = path.polygon_data._edb_object
             int_data = _poly.GetIntersectionType(pdata)
             if int_data == 0:
                 prims_to_delete.append(path)
@@ -2320,7 +2322,7 @@ class Edb(Database):
                 reference_prims.append(path)
 
         def clean_prim(prim_1):  # pragma: no cover
-            pdata = prim_1.polygon_data.edb_api
+            pdata = prim_1.polygon_data._edb_object
             int_data = _poly.GetIntersectionType(pdata)
             if int_data == 2:
                 if not inlcude_voids_in_extents:
@@ -2347,7 +2349,7 @@ class Edb(Database):
                     # points = list(p.Points)
                     list_void = []
                     if voids:
-                        voids_data = [void.polygon_data.edb_api for void in voids]
+                        voids_data = [void.polygon_data._edb_object for void in voids]
                         list_prims = subtract(p, voids_data)
                         for prim in list_prims:
                             if not prim.IsNull():
@@ -2396,7 +2398,7 @@ class Edb(Database):
         self.logger.reset_timer()
 
         i = 0
-        for _, val in self.components.components.items():
+        for _, val in self.components.instances.items():
             if val.numpins == 0:
                 val.edbcomponent.Delete()
                 i += 1
@@ -2580,28 +2582,6 @@ class Edb(Database):
         else:
             return "{0}{1}".format(value, units)
 
-    def arg_with_dim(self, Value, sUnits):
-        """Convert a number to a string with units. If value is a string, it's returned as is.
-
-        .. deprecated:: 0.6.56
-           Use :func:`number_with_units` property instead.
-
-        Parameters
-        ----------
-        Value : float, int, str
-            Input  number or string.
-        sUnits : optional
-            Units for formatting. The default is ``None``, which uses ``"meter"``.
-
-        Returns
-        -------
-        str
-           String concatenating the value and unit.
-
-        """
-        warnings.warn("Use :func:`number_with_units` instead.", DeprecationWarning)
-        return self.number_with_units(Value, sUnits)
-
     def _decompose_variable_value(self, value, unit_system=None):
         val, units = decompose_variable_value(value)
         if units and unit_system and units in AEDT_UNITS[unit_system]:
@@ -4128,6 +4108,7 @@ class Edb(Database):
         open_aedb_at_end=True,
         expand_polygons_size=0,
         expand_voids_size=0,
+        via_offset=True,
     ):
         """Assign automatically design and project variables with current values.
 
@@ -4163,6 +4144,12 @@ class Edb(Database):
             Full path and name for the new AEDB file. If None, then current aedb will be cutout.
         open_aedb_at_end : bool, optional
             Whether to open the cutout at the end. The default is ``True``.
+        expand_polygons_size : float, optional
+            Expansion size on polygons. Polygons will be expanded in all directions. The default is ``0``.
+        expand_voids_size : float, optional
+            Expansion size on polygon voids. Polygons voids will be expanded in all directions. The default is ``0``.
+        via_offset : bool, optional
+            Whether if offset the via position or not. The default is ``True``.
 
         Returns
         -------
@@ -4326,6 +4313,18 @@ class Edb(Database):
                         antipad.parameters = {"XSize": var, "YSize": var2}
                         parameters.append(val)
                         parameters.append(val2)
+
+        if via_offset:
+            var_x = "via_offset_x"
+            if var_x not in self.variables:
+                self.add_design_variable(var_x, 0.0)
+            var_y = "via_offset_y"
+            if var_y not in self.variables:
+                self.add_design_variable(var_y, 0.0)
+            for via in self.padstacks.instances.values():
+                if not via.is_pin and (not trace_net_filter or (trace_net_filter and via.net_name in trace_net_filter)):
+                    via.position = [f"{via.position[0]}+via_offset_x", f"{via.position[1]}+via_offset_y"]
+
         if expand_polygons_size:
             for poly in self.modeler.polygons:
                 if not poly.is_void:
@@ -4448,10 +4447,10 @@ class Edb(Database):
         for poly in polys:
             for void in poly.voids:
                 void_bbox = (
-                    void.polygon_data.edb_api.GetBBox().Item1.X.ToDouble(),
-                    void.polygon_data.edb_api.GetBBox().Item1.Y.ToDouble(),
-                    void.polygon_data.edb_api.GetBBox().Item2.X.ToDouble(),
-                    void.polygon_data.edb_api.GetBBox().Item2.Y.ToDouble(),
+                    void.polygon_data._edb_object.GetBBox().Item1.X.ToDouble(),
+                    void.polygon_data._edb_object.GetBBox().Item1.Y.ToDouble(),
+                    void.polygon_data._edb_object.GetBBox().Item2.X.ToDouble(),
+                    void.polygon_data._edb_object.GetBBox().Item2.Y.ToDouble(),
                 )
                 included_instances = list(padstack_instances_index.intersection(void_bbox))
                 if included_instances:
@@ -4484,10 +4483,10 @@ class Edb(Database):
 
         for void_info in void_padstacks:
             port_poly = cloned_edb.modeler.create_polygon(
-                main_shape=void_info[0].polygon_data.edb_api, layer_name="ref", net_name="GND"
+                main_shape=void_info[0].polygon_data._edb_object, layer_name="ref", net_name="GND"
             )
             pec_poly = cloned_edb.modeler.create_polygon(
-                main_shape=port_poly.polygon_data.edb_api, layer_name="port_pec", net_name="GND"
+                main_shape=port_poly.polygon_data._edb_object, layer_name="port_pec", net_name="GND"
             )
             pec_poly.scale(1.5)
 

pyedb/dotnet/edb_core/cell/hierarchy/component.py

@@ -958,7 +958,7 @@ class EDBComponent(Group):
         opening.append(bounding_box[3] + extra_soldermask_clearance)
 
         comp_layer = self.placement_layer
-        layer_names = list(self._pedb.stackup.stackup_layers.keys())
+        layer_names = list(self._pedb.stackup.layers.keys())
         layer_index = layer_names.index(comp_layer)
         if comp_layer in [layer_names[0] + layer_names[-1]]:
             return False

pyedb/dotnet/edb_core/cell/hierarchy/hierarchy_obj.py

@@ -48,3 +48,14 @@ class HierarchyObj(Connectable):
 class Group(HierarchyObj):
     def __init__(self, pedb, edb_object):
         super().__init__(pedb, edb_object)
+
+    def ungroup(self, recursive=False):
+        """Dissolve a group.
+
+        Parameters
+        ----------
+        recursive : bool, optional
+         If True, all subgroups will also be dissolved.
+
+        """
+        return self._edb_object.Ungroup(recursive)

pyedb/dotnet/edb_core/cell/layout.py

@@ -24,7 +24,8 @@
 This module contains these classes: `EdbLayout` and `Shape`.
 """
 from pyedb.dotnet.edb_core.cell.hierarchy.component import EDBComponent
-from pyedb.dotnet.edb_core.cell.primitive import Bondwire
+from pyedb.dotnet.edb_core.cell.primitive.bondwire import Bondwire
+from pyedb.dotnet.edb_core.cell.primitive.path import Path
 from pyedb.dotnet.edb_core.cell.terminal.bundle_terminal import BundleTerminal
 from pyedb.dotnet.edb_core.cell.terminal.edge_terminal import EdgeTerminal
 from pyedb.dotnet.edb_core.cell.terminal.padstack_instance_terminal import (
@@ -42,7 +43,6 @@ from pyedb.dotnet.edb_core.edb_data.nets_data import (
 from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
 from pyedb.dotnet.edb_core.edb_data.primitives_data import (
     EdbCircle,
-    EdbPath,
     EdbPolygon,
     EdbRectangle,
     EdbText,
@@ -206,26 +206,8 @@ class Layout(ObjBase):
         """
         prims = []
         for p in self._edb_object.Primitives:
-            if p.GetPrimitiveType().ToString() == "Rectangle":
-                prims.append(EdbRectangle(p, self._pedb))
-            elif p.GetPrimitiveType().ToString() == "Circle":
-                prims.append(EdbCircle(p, self._pedb))
-            elif p.GetPrimitiveType().ToString() == "Polygon":
-                prims.append(EdbPolygon(p, self._pedb))
-            elif p.GetPrimitiveType().ToString() == "Path":
-                prims.append(EdbPath(p, self._pedb))
-            elif p.GetPrimitiveType().ToString() == "Bondwire":
-                prims.append(Bondwire(self._pedb, p))
-            elif p.GetPrimitiveType().ToString() == "Text":
-                prims.append(EdbText(p, self._pedb))
-            elif p.GetPrimitiveType().ToString() == "PrimitivePlugin":
-                pass
-            elif p.GetPrimitiveType().ToString() == "Path3D":
-                pass
-            elif p.GetPrimitiveType().ToString() == "BoardBendDef":
-                pass
-            else:
-                pass
+            obj = self.find_object_by_id(p.GetId())
+            prims.append(obj)
         return prims
 
     @property
@@ -293,8 +275,33 @@ class Layout(ObjBase):
             ID of the object.
         """
         obj = self._pedb._edb.Cell.Connectable.FindById(self._edb_object, value)
+        if obj is None:
+            raise RuntimeError(f"Object Id {value} not found")
+
         if obj.GetObjType().ToString() == "PadstackInstance":
-            return EDBPadstackInstance(obj, self._pedb) if obj is not None else None
+            return EDBPadstackInstance(obj, self._pedb)
+
+        if obj.GetObjType().ToString() == "Primitive":
+            if obj.GetPrimitiveType().ToString() == "Rectangle":
+                return EdbRectangle(obj, self._pedb)
+            elif obj.GetPrimitiveType().ToString() == "Circle":
+                return EdbCircle(obj, self._pedb)
+            elif obj.GetPrimitiveType().ToString() == "Polygon":
+                return EdbPolygon(obj, self._pedb)
+            elif obj.GetPrimitiveType().ToString() == "Path":
+                return Path(self._pedb, obj)
+            elif obj.GetPrimitiveType().ToString() == "Bondwire":
+                return Bondwire(self._pedb, obj)
+            elif obj.GetPrimitiveType().ToString() == "Text":
+                return EdbText(obj, self._pedb)
+            elif obj.GetPrimitiveType().ToString() == "PrimitivePlugin":
+                pass
+            elif obj.GetPrimitiveType().ToString() == "Path3D":
+                pass
+            elif obj.GetPrimitiveType().ToString() == "BoardBendDef":
+                pass
+            else:
+                pass
 
     def find_net_by_name(self, value: str):
         """Find a net object by name

pyedb/dotnet/edb_core/cell/layout_obj.py

@@ -27,15 +27,6 @@ from pyedb.dotnet.edb_core.utilities.obj_base import ObjBase
 class LayoutObj(ObjBase):
     """Manages EDB functionalities for the layout object."""
 
-    def __getattr__(self, key):  # pragma: no cover
-        try:
-            return super().__getattribute__(key)
-        except AttributeError:
-            try:
-                return getattr(self._edb_object, key)
-            except AttributeError:
-                raise AttributeError(f"Attribute '{key}' not present")
-
     def __init__(self, pedb, edb_object):
         super().__init__(pedb, edb_object)
 

pyedb/dotnet/edb_core/cell/primitive/__init__.py

@@ -0,0 +1,3 @@
+from pathlib import Path
+
+workdir = Path(__file__).parent

pyedb/dotnet/edb_core/cell/{primitive.py → primitive/bondwire.py}

@@ -20,152 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from pyedb.dotnet.edb_core.cell.connectable import Connectable
-
-
-class Primitive(Connectable):
-    """Manages EDB functionalities for a primitives.
-    It inherits EDB Object properties.
-
-    Examples
-    --------
-    >>> from pyedb import Edb
-    >>> edb = Edb(myedb, edbversion="2021.2")
-    >>> edb_prim = edb.modeler.primitives[0]
-    >>> edb_prim.is_void # Class Property
-    >>> edb_prim.IsVoid() # EDB Object Property
-    """
-
-    def __init__(self, pedb, edb_object):
-        super().__init__(pedb, edb_object)
-        self._app = self._pedb
-        self._core_stackup = pedb.stackup
-        self._core_net = pedb.nets
-        self.primitive_object = self._edb_object
-
-        bondwire_type = self._pedb._edb.Cell.Primitive.BondwireType
-        self._bondwire_type = {
-            "invalid": bondwire_type.Invalid,
-            "apd": bondwire_type.ApdBondwire,
-            "jedec_4": bondwire_type.Jedec4Bondwire,
-            "jedec_5": bondwire_type.Jedec5Bondwire,
-            "num_of_bondwire_type": bondwire_type.NumOfBondwireType,
-        }
-        bondwire_cross_section_type = self._pedb._edb.Cell.Primitive.BondwireCrossSectionType
-        self._bondwire_cross_section_type = {
-            "invalid": bondwire_cross_section_type.Invalid,
-            "round": bondwire_cross_section_type.BondwireRound,
-            "rectangle": bondwire_cross_section_type.BondwireRectangle,
-        }
-
-    @property
-    def type(self):
-        """Return the type of the primitive.
-
-        Expected output is among ``"Circle"``, ``"Rectangle"``,``"Polygon"``,``"Path"`` or ``"Bondwire"``.
-
-        Returns
-        -------
-        str
-        """
-        try:
-            return self._edb_object.GetPrimitiveType().ToString()
-        except AttributeError:  # pragma: no cover
-            return ""
-
-    @property
-    def primitive_type(self):
-        """Return the type of the primitive.
-
-        Expected output is among ``"circle"``, ``"rectangle"``,``"polygon"``,``"path"`` or ``"bondwire"``.
-
-        Returns
-        -------
-        str
-        """
-        return self._edb_object.GetPrimitiveType().ToString().lower()
-
-    @property
-    def net_name(self):
-        """Get the primitive net name.
-
-        Returns
-        -------
-        str
-        """
-        return self.net.GetName()
-
-    @net_name.setter
-    def net_name(self, name):
-        if isinstance(name, str):
-            net = self._app.nets.nets[name].net_object
-            self.primitive_object.SetNet(net)
-        else:
-            try:
-                self.net = name.name
-            except:  # pragma: no cover
-                self._app.logger.error("Failed to set net name.")
-
-    @property
-    def layer(self):
-        """Get the primitive edb layer object."""
-        try:
-            layer_name = self.primitive_object.GetLayer().GetName()
-            return self._pedb.stackup.layers[layer_name]
-        except (KeyError, AttributeError):  # pragma: no cover
-            return None
-
-    @property
-    def layer_name(self):
-        """Get the primitive layer name.
-
-        Returns
-        -------
-        str
-        """
-        try:
-            return self.layer.name
-        except (KeyError, AttributeError):  # pragma: no cover
-            return None
-
-    @layer_name.setter
-    def layer_name(self, val):
-        layer_list = list(self._core_stackup.layers.keys())
-        if isinstance(val, str) and val in layer_list:
-            layer = self._core_stackup.layers[val]._edb_layer
-            if layer:
-                self.primitive_object.SetLayer(layer)
-            else:
-                raise AttributeError("Layer {} not found.".format(val))
-        elif isinstance(val, type(self._core_stackup.layers[layer_list[0]])):
-            try:
-                self.primitive_object.SetLayer(val._edb_layer)
-            except:
-                raise AttributeError("Failed to assign new layer on primitive.")
-        else:
-            raise AttributeError("Invalid input value")
-
-    @property
-    def is_void(self):
-        """Either if the primitive is a void or not.
-
-        Returns
-        -------
-        bool
-        """
-        try:
-            return self._edb_object.IsVoid()
-        except AttributeError:  # pragma: no cover
-            return None
-
-    def get_connected_objects(self):
-        """Get connected objects.
-
-        Returns
-        -------
-        list
-        """
-        return self._pedb.get_connected_objects(self._layout_obj_instance)
+from pyedb.dotnet.edb_core.cell.primitive.primitive import Primitive
 
 
 class Bondwire(Primitive):