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

pyedb/edb_logger.py

@@ -29,8 +29,6 @@ import sys
 import tempfile
 import time
 
-from pyedb.generic.settings import settings
-
 
 class Msg:
     (INFO, WARNING, ERROR, FATAL) = range(4)
@@ -91,14 +89,17 @@ class EdbLogger(object):
         Whether to write log messages to stdout. The default is ``False``.
     """
 
-    def __init__(self, level=logging.DEBUG, filename=None, to_stdout=False):
+    log_file = ""
+
+    def __init__(self, level=logging.DEBUG, filename=None, to_stdout=False, settings=None):
+        self.settings = settings
         self._std_out_handler = None
         self._files_handlers = []
         self.level = level
         self.filename = filename or settings.logger_file_path
         settings.logger_file_path = self.filename
 
-        self._global = logging.getLogger("Global")
+        self._global = logging.getLogger("Edb")
         if not settings.enable_logger:
             self._global.addHandler(logging.NullHandler())
             return
@@ -123,6 +124,7 @@ class EdbLogger(object):
                 encoding="utf-8",
                 delay=0,
             )
+            self.log_file = log_file
             my_handler.setFormatter(self.formatter)
             my_handler.setLevel(self.level)
             if not global_handler and settings.global_log_file_name:
@@ -171,11 +173,11 @@ class EdbLogger(object):
 
     @property
     def _log_on_file(self):
-        return settings.enable_file_logs
+        return self.settings.enable_file_logs
 
     @_log_on_file.setter
     def _log_on_file(self, val):
-        settings.enable_file_logs = val
+        self.settings.enable_file_logs = val
 
     @property
     def logger(self):
@@ -334,7 +336,7 @@ class EdbLogger(object):
 
     def info(self, msg, *args, **kwargs):
         """Write an info message to the global logger."""
-        if not settings.enable_logger:
+        if not self.settings.enable_logger:
             return
         if args:
             try:
@@ -348,7 +350,7 @@ class EdbLogger(object):
     def info_timer(self, msg, start_time=None, *args, **kwargs):
         """Write an info message to the global logger with elapsed time.
         Message will have an appendix of type Elapsed time: time."""
-        if not settings.enable_logger:
+        if not self.settings.enable_logger:
             return
         if not start_time:
             start_time = self._timer
@@ -373,7 +375,7 @@ class EdbLogger(object):
 
     def warning(self, msg, *args, **kwargs):
         """Write a warning message to the global logger."""
-        if not settings.enable_logger:
+        if not self.settings.enable_logger:
             return
         if args:
             try:
@@ -397,7 +399,7 @@ class EdbLogger(object):
 
     def debug(self, msg, *args, **kwargs):
         """Write a debug message to the global logger."""
-        if not settings.enable_debug_logger or not settings.enable_logger:
+        if not self.settings.enable_debug_logger or not self.settings.enable_logger:
             return
         if args:
             try:
@@ -413,20 +415,3 @@ class EdbLogger(object):
         """Global logger."""
         self._global = logging.getLogger("Global")
         return self._global
-
-
-logger = logging.getLogger("Global")
-if any("aedt_logger" in str(i) for i in logger.filters):
-    from ansys.aedt.core.generic.settings import settings as pyaedt_settings
-
-    from pyedb.generic.settings import settings as pyaedb_settings
-
-    pyedb_logger = pyaedt_settings.logger
-    pyaedb_settings.use_pyaedt_log = True
-    pyaedb_settings.logger = pyedb_logger
-
-else:
-    pyedb_logger = EdbLogger(to_stdout=settings.enable_screen_logs)
-    from pyedb.generic.settings import settings as pyaedb_settings
-
-    pyaedb_settings.logger = pyedb_logger

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/extensions/via_design_backend.py

@@ -663,7 +663,7 @@ class ViaDesignBackend:
         pitch = self.cfg["general"]["pitch"]
 
         board = Board(
-            stackup=self.cfg["stackup"],
+            stackup=self.cfg["stackup"] if isinstance(self.cfg["stackup"], list) else self.cfg["stackup"]["layers"],
             padstack_defs=self.cfg["padstack_defs"],
             outline_extent=outline_extent,
             pitch=pitch,
@@ -673,9 +673,12 @@ class ViaDesignBackend:
         )
         board.populate_config(cfg_json)
 
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        with open(self.output_dir / "config.json", "w") as f:
+            json.dump(cfg_json, f, indent=4)
         self.app = Edb(
             edbpath=str((Path(self.output_dir) / self.cfg["title"]).with_suffix(".aedb")), edbversion=self.version
         )
         self.app.configuration.load(cfg_json, apply_file=True)
-        self.app.save_edb()
-        self.app.close_edb()
+        self.app.save()
+        self.app.close()

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