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

pyedb/extensions/create_cell_array.py

@@ -0,0 +1,394 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""
+This module contains the array building feature from unit cell.
+"""
+import itertools
+from typing import Optional, Union
+
+from pyedb import Edb
+
+
+# ----------------------
+# Public façade function
+# ----------------------
+def create_array_from_unit_cell(
+    edb: Edb,
+    x_number: int = 2,
+    y_number: int = 2,
+    offset_x: Optional[Union[int, float]] = None,
+    offset_y: Optional[Union[int, float]] = None,
+) -> bool:
+    """
+    Create a 2-D rectangular array from the current EDB unit cell.
+
+    The function duplicates every primitive (polygon, rectangle, circle), path,
+    padstack via, and component found in the active layout and places copies on
+    a regular grid defined by *offset_x* and *offset_y*. If the offsets are
+    omitted they are automatically derived from the bounding box of the first
+    primitive found on the layer called **outline** (case-insensitive).
+
+    Parameters
+    ----------
+    edb : pyedb.Edb
+        An open Edb instance whose active layout is used as the unit cell.
+    x_number : int, optional
+        Number of columns (X-direction). Must be > 0.  Defaults to 2.
+    y_number : int, optional
+        Number of rows (Y-direction). Must be > 0.  Defaults to 2.
+    offset_x : int | float | None, optional
+        Horizontal pitch (distance between cell origins).  When *None* the
+        value is derived from the outline geometry.
+    offset_y : int | float | None, optional
+        Vertical pitch (distance between cell origins).  When *None* the
+        value is derived from the outline geometry.
+
+    Returns
+    -------
+    bool
+        ``True`` if the operation completed successfully.
+
+    Raises
+    ------
+    ValueError
+        If *x_number* or *y_number* are non-positive.
+    RuntimeError
+        If no outline is found and the offsets were not supplied, or if the
+        outline is not a supported type (polygon/rectangle).
+
+    Notes
+    -----
+    The routine is technology-agnostic; it delegates all EDB-specific calls to
+    small adapter classes that handle either the **gRPC** or **.NET** back-end
+    transparently.
+
+    Examples
+    --------
+    >>> from pyedb import Edb
+    >>> edb = Edb("unit_cell.aedb")
+    >>> create_array_from_unit_cell(edb, x_number=4, y_number=3)
+    True
+    """
+    if edb.grpc:
+        adapter = _GrpcAdapter(edb)
+    else:
+        adapter = _DotNetAdapter(edb)
+    return __create_array_from_unit_cell_impl(edb, adapter, x_number, y_number, offset_x, offset_y)
+
+
+# ------------------------------------------------------------------
+# Implementation (technology-agnostic)
+# ------------------------------------------------------------------
+def __create_array_from_unit_cell_impl(
+    edb: Edb,
+    adapter: "_BaseAdapter",
+    x_number: int,
+    y_number: int,
+    offset_x: Optional[Union[int, float]],
+    offset_y: Optional[Union[int, float]],
+) -> bool:
+    """
+    Inner worker that performs the actual replication.
+
+    Parameters
+    ----------
+    edb : pyedb.Edb
+        Edb instance (already validated by the façade).
+    adapter : _BaseAdapter
+        Technology-specific adapter (gRPC or .NET).
+    x_number : int
+        Number of columns.
+    y_number : int
+        Number of rows.
+    offset_x : float
+        Absolute pitch in X (always resolved by the caller).
+    offset_y : float
+        Absolute pitch in Y (always resolved by the caller).
+
+    Returns
+    -------
+    bool
+        ``True`` when finished.
+    """
+    # ---------- Sanity & auto-pitch detection ----------
+    if x_number <= 0 or y_number <= 0:
+        raise ValueError("x_number and y_number must be positive integers")
+
+    if offset_x is None or offset_y is None:
+        edb.logger.info("Auto-detecting outline extents")
+        outline_prims = [p for p in edb.modeler.primitives if p.layer_name.lower() == "outline"]
+        if not outline_prims:
+            raise RuntimeError("No outline found. Provide offset_x / offset_y or add an 'Outline' layer primitive.")
+        outline = outline_prims[0]
+        if not adapter.is_supported_outline(outline):
+            raise RuntimeError("Outline primitive is not a polygon/rectangle. Provide offset_x / offset_y.")
+        offset_x, offset_y = adapter.pitch_from_outline(outline)
+
+    # ---------- Collect everything we have to replicate ----------
+    primitives = [p for p in edb.modeler.primitives if adapter.is_primitive_to_copy(p)]
+    paths = list(edb.modeler.paths)
+    vias = list(edb.padstacks.vias.values())
+    components = list(edb.components.instances.values())
+
+    # ---------- Replication loops ----------
+    edb.logger.info(f"Starting array replication {x_number}×{y_number}")
+    for i, j in itertools.product(range(x_number), range(y_number)):
+        if i == 0 and j == 0:
+            continue  # original already exists
+
+        dx = edb.value(offset_x * i)
+        dy = edb.value(offset_y * j)
+
+        # Primitives & voids
+        for prim in primitives:
+            new_poly = adapter.duplicate_primitive(prim, dx, dy, i, j)
+            for void in prim.voids:
+                adapter.duplicate_void(new_poly, void, dx, dy)
+
+        # Paths
+        for path in paths:
+            adapter.duplicate_path(path, dx, dy, i, j)
+
+        # Stand-alone vias
+        for via in (v for v in vias if not v.component):
+            adapter.duplicate_standalone_via(via, dx, dy, i, j)
+
+        # Components
+        for comp in components:
+            adapter.duplicate_component(comp, dx, dy, i, j)
+
+    edb.logger.info("Array replication finished successfully")
+    return True
+
+
+# ------------------------------------------------------------------
+# Technology-specific adapters
+# ------------------------------------------------------------------
+class _BaseAdapter:
+    """Abstract adapter defining the required interface."""
+
+    def __init__(self, edb: Edb):
+        self.edb = edb
+
+    # ---- Outline helpers ----
+    def is_supported_outline(self, outline) -> bool:
+        """Return True when *outline* is a primitive type from which pitch can be inferred."""
+        raise NotImplementedError
+
+    def pitch_from_outline(self, outline) -> tuple[float, float]:
+        """
+        Compute the (offset_x, offset_y) pitch from the bounding box of *outline*.
+
+        Returns
+        -------
+        tuple[float, float]
+            (width, height) of the outline primitive in database units.
+        """
+        raise NotImplementedError
+
+    # ---- Duplication helpers ----
+    def is_primitive_to_copy(self, prim) -> bool:
+        """Return True when *prim* is a primitive that must be duplicated."""
+        raise NotImplementedError
+
+    def duplicate_primitive(self, prim, dx, dy, i, j):
+        """Return a new primitive translated by (dx, dy)."""
+        raise NotImplementedError
+
+    def duplicate_void(self, new_poly, void, dx, dy):
+        """Add a translated copy of *void* to *new_poly*."""
+        raise NotImplementedError
+
+    def duplicate_path(self, path, dx, dy, i, j):
+        """Create a translated copy of *path*."""
+        raise NotImplementedError
+
+    def duplicate_standalone_via(self, via, dx, dy, i, j):
+        """Create a translated copy of a stand-alone via."""
+        raise NotImplementedError
+
+    def duplicate_component(self, comp, dx, dy, i, j):
+        """Create a translated copy of *comp* (including its pins)."""
+        raise NotImplementedError
+
+
+class _GrpcAdapter(_BaseAdapter):
+    """Adapter for the gRPC-based EDB back-end."""
+
+    def is_supported_outline(self, outline) -> bool:
+        return outline.type in {"polygon", "rectangle"}
+
+    def pitch_from_outline(self, outline):
+        bbox = outline.polygon_data.bbox()
+        return self.edb.value(bbox[1].x - bbox[0].x), self.edb.value(bbox[1].y - bbox[0].y)
+
+    def is_primitive_to_copy(self, prim):
+        return prim.type in {"polygon", "rectangle", "circle"}
+
+    def duplicate_primitive(self, prim, dx, dy, i, j):
+        moved_pd = prim.polygon_data.move((dx, dy))
+        return self.edb.modeler.create_polygon(
+            moved_pd,
+            layer_name=prim.layer.name,
+            net_name=prim.net.name,
+        )
+
+    def duplicate_void(self, new_poly, void, dx, dy):
+        new_poly.add_void(void.polygon_data.move((dx, dy)))
+
+    def duplicate_path(self, path, dx, dy, i, j):
+        moved_line = path.cast().center_line.move((dx, dy))
+        self.edb.modeler.create_trace(
+            moved_line,
+            width=path.width,
+            layer_name=path.layer.name,
+            net_name=path.net.name,
+        )
+
+    def duplicate_standalone_via(self, via, dx, dy, i, j):
+        from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
+
+        pos = via.position
+        PadstackInstance.create(
+            self.edb.active_layout,
+            net=via.net,
+            name=f"{via.name}_i{i}_j{j}",
+            padstack_def=self.edb.padstacks.definitions[via.padstack_definition],
+            position_x=pos[0] + dx,
+            position_y=pos[1] + dy,
+            rotation=0.0,
+            top_layer=self.edb.stackup.layers[via.start_layer],
+            bottom_layer=self.edb.stackup.layers[via.stop_layer],
+        )
+
+    def duplicate_component(self, comp, dx, dy, i, j):
+        from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
+
+        new_pins = []
+        for pin in comp.pins.values():
+            pos = pin.position
+            new_pin = PadstackInstance.create(
+                self.edb.active_layout,
+                net=pin.net,
+                name=f"{pin.name}_i{i}_j{j}",
+                padstack_def=self.edb.padstacks.definitions[pin.padstack_definition],
+                position_x=pos[0] + dx,
+                position_y=pos[1] + dy,
+                rotation=0.0,
+                top_layer=self.edb.stackup.layers[pin.start_layer],
+                bottom_layer=self.edb.stackup.layers[pin.stop_layer],
+            )
+            new_pins.append(new_pin)
+
+        if new_pins:
+            res = self.edb.value(comp.res_value) if hasattr(comp, "res_value") and comp.res_value else None
+            cap = self.edb.value(comp.cap_value) if hasattr(comp, "cap_value") and comp.cap_value else None
+            ind = self.edb.value(comp.ind_value) if hasattr(comp, "ind_value") and comp.ind_value else None
+            new_comp = self.edb.components.create(
+                pins=new_pins,
+                component_name=f"{comp.name}_array_{i}_{j}",
+                placement_layer=comp.placement_layer,
+                component_part_name=comp.part_name,
+                r_value=res,
+                l_value=ind,
+                c_value=cap,
+            )
+            if hasattr(comp, "component_property") and comp.component_property:
+                new_comp.component_property = comp.component_property
+
+
+class _DotNetAdapter(_BaseAdapter):
+    """Adapter for the legacy .NET-based EDB back-end."""
+
+    def is_supported_outline(self, outline) -> bool:
+        return outline.type.lower() in {"polygon", "rectangle"}
+
+    def pitch_from_outline(self, outline):
+        bbox = outline.polygon_data.bounding_box
+        return self.edb.value(bbox[1][0] - bbox[0][0]), self.edb.value(bbox[1][1] - bbox[0][1])
+
+    def is_primitive_to_copy(self, prim):
+        return prim.type.lower() in {"polygon", "rectangle", "circle"}
+
+    def duplicate_primitive(self, prim, dx, dy, i, j):
+        from pyedb.dotnet.database.geometry.point_data import PointData
+
+        vector = PointData.create_from_xy(self.edb, x=dx, y=dy)
+        moved_pd = prim.polygon_data
+        moved_pd._edb_object.Move(vector._edb_object)
+        return self.edb.modeler.create_polygon(
+            moved_pd,
+            layer_name=prim.layer.name,
+            net_name=prim.net.name,
+        )
+
+    def duplicate_void(self, new_poly, void, dx, dy):
+        from pyedb.dotnet.database.geometry.point_data import PointData
+
+        vector = PointData.create_from_xy(self.edb, x=dx, y=dy)
+        void_polygon_data = void.polygon_data
+        void_polygon_data._edb_object.Move(vector._edb_object)
+        new_poly.add_void(void_polygon_data.points)
+
+    def duplicate_path(self, path, dx, dy, i, j):
+        from pyedb.dotnet.database.geometry.point_data import PointData
+
+        vector = PointData.create_from_xy(self.edb, x=dx, y=dy)
+        moved_path = path._edb_object.GetCenterLine()
+        moved_path.Move(vector._edb_object)
+        moved_path = [[pt.X.ToDouble(), pt.Y.ToDouble()] for pt in list(moved_path.Points)]
+        self.edb.modeler.create_trace(
+            path_list=list(moved_path),
+            width=path.width,
+            layer_name=path.layer.name,
+            net_name=path.net.name,
+        )
+
+    def duplicate_standalone_via(self, via, dx, dy, i, j):
+        pos = via.position
+        self.edb.padstacks.place(
+            [pos[0] + dx, pos[1] + dy],
+            via.padstack_definition,
+            via_name=f"{via.aedt_name}_i{i}_j{j}",
+        )
+
+    def duplicate_component(self, comp, dx, dy, i, j):
+        new_pins = []
+        for pin in comp.pins.values():
+            pos = pin.position
+            new_pin = self.edb.padstacks.place(
+                [pos[0] + dx, pos[1] + dy],
+                pin.padstack_definition,
+                via_name=f"{pin.aedt_name}_i{i}_j{j}",
+            )
+            new_pins.append(new_pin)
+
+        if new_pins:
+            new_comp = self.edb.components.create(
+                pins=new_pins,
+                component_name=f"{comp.name}_array_{i}_{j}",
+                placement_layer=comp.placement_layer,
+                component_part_name=comp.part_name,
+            )
+            if hasattr(comp, "component_property"):
+                new_comp._edb_object.SetComponentProperty(comp.component_property)

pyedb/generic/data_handlers.py

@@ -2,8 +2,8 @@
 from decimal import Decimal
 import json
 import math
-import random
 import re
+import secrets
 import string
 
 from pyedb.generic.general_methods import settings
@@ -54,7 +54,7 @@ def random_string(length=6, only_digits=False, char_set=None):  # pragma: no cov
             char_set = string.digits
         else:
             char_set = string.ascii_uppercase + string.digits
-    random_str = "".join(random.choice(char_set) for _ in range(int(length)))
+    random_str = "".join(secrets.choice(char_set) for _ in range(int(length)))
     return random_str
 
 
@@ -85,9 +85,8 @@ def unique_string_list(element_list, only_string=True):  # pragma: no cover
                 pass
             raise Exception(error_message)
 
-        if only_string:
-            non_string_entries = [x for x in element_list if type(x) is not str]
-            assert not non_string_entries, "Invalid list entries {} are not a string!".format(non_string_entries)
+        if only_string and any(not isinstance(x, str) for x in element_list):
+            raise TypeError("Invalid list entries, some elements are not of type string.")
 
     return element_list
 
@@ -104,10 +103,10 @@ def string_list(element_list):  # pragma: no cover
     -------
 
     """
+    if not isinstance(element_list, (str, list)):
+        raise TypeError("Input must be a list or a string")
     if isinstance(element_list, str):
         element_list = [element_list]
-    else:
-        assert isinstance(element_list, str), "Input must be a list or a string"
     return element_list
 
 

pyedb/generic/design_types.py

@@ -57,9 +57,11 @@ def Edb(
     oproject=None,
     student_version=False,
     use_ppe=False,
+    map_file=None,
     technology_file=None,
     grpc=False,
     control_file=None,
+    layer_filter=None,
 ):
     """Provides the EDB application interface.
 
@@ -78,7 +80,7 @@ def Edb(
         isreadonly : bool, optional
             Whether to open EBD in read-only mode when it is
             owned by HFSS 3D Layout. The default is ``False``.
-        edbversion : str, optional
+        version : str, optional
             Version of EDB to use. The default is ``"2021.2"``.
         isaedtowned : bool, optional
             Whether to launch EDB from HFSS 3D Layout. The
@@ -87,10 +89,20 @@ def Edb(
             Reference to the AEDT project object.
         student_version : bool, optional
             Whether to open the AEDT student version. The default is ``False.``
+        use_ppe : bool, optional
+            Whether to use PPE license. The default is ``False``.
         technology_file : str, optional
             Full path to technology file to be converted to xml before importing or xml. Supported by GDS format only.
         grpc : bool, optional
             Whether to enable gRPC. Default value is ``False``.
+        layer_filter: str,optional
+            Layer filter .txt file.
+        map_file : str, optional
+            Layer map .map file.
+        control_file : str, optional
+            Path to the XML file. The default is ``None``, in which case an attempt is made to find
+            the XML file in the same directory as the board file. To succeed, the XML file and board file
+            must have the same name. Only the extension differs.
 
         Returns
         -------
@@ -263,7 +275,6 @@ def Edb(
     if grpc is False and settings.edb_dll_path is not None:
         # Check if the user specified a .dll path
         settings.logger.info(f"Force to use .dll from {settings.edb_dll_path} defined in settings.")
-        settings.specified_version = "unknown"
     elif version is None:
         if settings.specified_version is not None:
             settings.logger.info(f"Use {settings.specified_version} defined in settings.")
@@ -324,8 +335,10 @@ def Edb(
             isaedtowned=isaedtowned,
             oproject=oproject,
             use_ppe=use_ppe,
-            technology_file=technology_file,
             control_file=control_file,
+            map_file=map_file,
+            technology_file=technology_file,
+            layer_filter=layer_filter,
         )
 
 

pyedb/generic/filesystem.py

@@ -1,5 +1,5 @@
 import os
-import random
+import secrets
 import shutil
 import string
 
@@ -44,7 +44,10 @@ class Scratch:
         self._volatile = volatile
         self._cleaned = True
         char_set = string.ascii_uppercase + string.digits
-        self._scratch_path = os.path.normpath(os.path.join(local_path, "scratch" + "".join(random.sample(char_set, 6))))
+        generator = secrets.SystemRandom()
+        self._scratch_path = os.path.normpath(
+            os.path.join(local_path, "scratch" + "".join(secrets.SystemRandom.sample(generator, char_set, 6)))
+        )
         if os.path.exists(self._scratch_path):
             try:
                 self.remove()

pyedb/generic/general_methods.py

@@ -35,8 +35,8 @@ import itertools
 import logging
 import math
 import os
-import random
 import re
+import secrets
 import string
 import sys
 import tempfile
@@ -254,7 +254,7 @@ def generate_unique_name(rootname, suffix="", n=6):
 
     """
     char_set = string.ascii_uppercase + string.digits
-    uName = "".join(random.choice(char_set) for _ in range(n))
+    uName = "".join(secrets.choice(char_set) for _ in range(n))
     unique_name = rootname + "_" + uName
     if suffix:
         unique_name += "_" + suffix

pyedb/generic/settings.py

@@ -21,6 +21,7 @@
 # SOFTWARE.
 
 import os
+from pathlib import Path
 import re
 import sys
 import time
@@ -248,6 +249,9 @@ class Settings(object):
     @edb_dll_path.setter
     def edb_dll_path(self, value):
         if os.path.exists(value):
+            ver = Path(value).parts[-2]
+            version, release = ver[-3:-1], ver[-1]
+            self.specified_version = f"20{version}.{release}"
             self._edb_dll_path = value
 
     @property

pyedb/grpc/database/components.py

@@ -1065,6 +1065,9 @@ class Components(object):
             ComponentGroup as GrpcComponentGroup,
         )
 
+        if not pins:
+            raise ValueError("Pins must be a list of PadstackInstance objects.")
+
         if not component_name:
             component_name = generate_unique_name("Comp_")
         if component_part_name:
@@ -1074,7 +1077,10 @@ class Components(object):
         if not compdef:
             return False
         new_cmp = GrpcComponentGroup.create(self._active_layout, component_name, compdef.name)
-        hosting_component_location = pins[0].component.transform
+        if hasattr(pins[0], "component") and pins[0].component:
+            hosting_component_location = pins[0].component.transform
+        else:
+            hosting_component_location = None
         if not len(pins) == len(compdef.component_pins):
             self._pedb.logger.error(
                 f"Number on pins {len(pins)} does not match component definition number "
@@ -1092,7 +1098,18 @@ class Components(object):
         if new_cmp_layer_name in self._pedb.stackup.signal_layers:
             new_cmp_placement_layer = self._pedb.stackup.signal_layers[new_cmp_layer_name]
             new_cmp.placement_layer = new_cmp_placement_layer
-        new_cmp.component_type = GrpcComponentType.OTHER
+        if r_value:
+            new_cmp.component_type = GrpcComponentType.RESISTOR
+            is_rlc = True
+        elif c_value:
+            new_cmp.component_type = GrpcComponentType.CAPACITOR
+            is_rlc = True
+        elif l_value:
+            new_cmp.component_type = GrpcComponentType.INDUCTOR
+            is_rlc = True
+        else:
+            new_cmp.component_type = GrpcComponentType.OTHER
+            is_rlc = False
         if is_rlc and len(pins) == 2:
             rlc = GrpcRlc()
             rlc.is_parallel = is_parallel
@@ -1125,7 +1142,8 @@ class Components(object):
             component_property = new_cmp.component_property
             component_property.model = rlc_model
             new_cmp.component_property = component_property
-        new_cmp.transform = hosting_component_location
+        if hosting_component_location:
+            new_cmp.transform = hosting_component_location
         new_edb_comp = Component(self._pedb, new_cmp)
         self._cmp[new_cmp.name] = new_edb_comp
         return new_edb_comp
@@ -1666,7 +1684,9 @@ class Components(object):
                     if comp.partname == part_name:
                         pass
                     else:
-                        pinlist = self._pedb.padstacks.get_instances(refdes)
+                        pinlist = list(self.instances[refdes].pins.values())
+                        if not pinlist:
+                            continue
                         if not part_name in self.definitions:
                             comp_def = ComponentDef.create(self._db, part_name, None)
                             # for pin in range(len(pinlist)):