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

pyedb/dotnet/database/utilities/siwave_simulation_setup.py

@@ -15,6 +15,7 @@ from pyedb.dotnet.database.sim_setup_data.io.siwave import (
 )
 from pyedb.dotnet.database.utilities.simulation_setup import SimulationSetup
 from pyedb.generic.general_methods import is_linux
+from pyedb.generic.settings import settings
 
 
 def _parse_value(v):
@@ -79,8 +80,10 @@ def clone_edb_sim_setup_info(source, target):
             except TypeError:
                 try:
                     setter.__setattr__(k, str(value))
-                except:
-                    pass
+                except Exception as e:
+                    settings.logger.warning(
+                        f"Failed to update attribute {k} with value {value} - {type(e).__name__}: {str(e)}"
+                    )
 
 
 class SiwaveSimulationSetup(SimulationSetup):

pyedb/dotnet/edb.py

@@ -25,6 +25,7 @@
 This module is implicitly loaded in HFSS 3D Layout when launched.
 
 """
+
 from datetime import datetime
 from itertools import combinations
 import os
@@ -43,7 +44,6 @@ import rtree
 
 from pyedb.configuration.configuration import Configuration
 import pyedb.dotnet
-from pyedb.dotnet.database.Variables import decompose_variable_value
 from pyedb.dotnet.database.cell.layout import Layout
 from pyedb.dotnet.database.cell.terminal.terminal import Terminal
 from pyedb.dotnet.database.components import Components
@@ -92,6 +92,7 @@ from pyedb.dotnet.database.utilities.siwave_simulation_setup import (
     SiwaveSimulationSetup,
 )
 from pyedb.dotnet.database.utilities.value import Value
+from pyedb.dotnet.database.Variables import decompose_variable_value
 from pyedb.generic.constants import AEDT_UNITS, SolverType, unit_converter
 from pyedb.generic.general_methods import generate_unique_name, is_linux, is_windows
 from pyedb.generic.process import SiwaveSolve
@@ -152,19 +153,19 @@ class Edb:
 
     Add a new variable named "s1" to the ``Edb`` instance.
 
-    >>> app['s1'] = "0.25 mm"
-    >>> app['s1'].tofloat
+    >>> app["s1"] = "0.25 mm"
+    >>> app["s1"].tofloat
     >>> 0.00025
-    >>> app['s1'].tostring
+    >>> app["s1"].tostring
     >>> "0.25mm"
 
     or add a new parameter with description:
 
-    >>> app['s2'] = ["20um", "Spacing between traces"]
-    >>> app['s2'].value
+    >>> app["s2"] = ["20um", "Spacing between traces"]
+    >>> app["s2"].value
     >>> 1.9999999999999998e-05
-    >>> app['s2'].description
-    >>> 'Spacing between traces'
+    >>> app["s2"].description
+    >>> "Spacing between traces"
 
     Create an ``Edb`` object and open the specified project.
 
@@ -1852,8 +1853,11 @@ class Edb:
                                         convert_py_list_to_net_list(list(obj_data)),
                                         convert_py_list_to_net_list(voids_poly),
                                     )
-                        except:
-                            pass
+                        except Exception as e:
+                            self.logger.error(
+                                f"A(n) {type(e).__name__} error occurred in method _create_conformal of "
+                                f"class Edb at iteration {k} for data {i}: {str(e)}"
+                            )
                         finally:
                             unite_polys.extend(list(obj_data))
             _poly_unite = self.core.Geometry.PolygonData.Unite(convert_py_list_to_net_list(unite_polys))
@@ -2048,7 +2052,7 @@ class Edb:
         Examples
         --------
         >>> from pyedb import Edb
-        >>> edb = Edb(r'C:\\test.aedb', version="2022.2")
+        >>> edb = Edb(r"C:\\test.aedb", version="2022.2")
         >>> edb.logger.info_timer("Edb Opening")
         >>> edb.logger.reset_timer()
         >>> start = time.time()
@@ -2058,7 +2062,7 @@ class Edb:
         >>>           signal_list.append(net)
         >>> power_list = ["PGND"]
         >>> edb.cutout(signal_list=signal_list, reference_list=power_list, extent_type="Conforming")
-        >>> end_time = str((time.time() - start)/60)
+        >>> end_time = str((time.time() - start) / 60)
         >>> edb.logger.info("Total legacy cutout time in min %s", end_time)
         >>> edb.nets.plot(signal_list, None, color_by_net=True)
         >>> edb.nets.plot(power_list, None, color_by_net=True)
@@ -2291,8 +2295,8 @@ class Edb:
                 if os.path.exists(source) and not os.path.exists(target):
                     try:
                         shutil.copy(source, target)
-                    except:
-                        pass
+                    except Exception as e:
+                        self.logger.error(f"Failed to copy {source} to {target} - {type(e).__name__}: {str(e)}")
         elif open_cutout_at_end:
             self._active_cell = _cutout
             self._init_objects()
@@ -2708,7 +2712,7 @@ class Edb:
         Examples
         --------
         >>> from pyedb import Edb
-        >>> edb = Edb(r'C:\\test.aedb', version="2022.2")
+        >>> edb = Edb(r"C:\\test.aedb", version="2022.2")
         >>> edb.logger.info_timer("Edb Opening")
         >>> edb.logger.reset_timer()
         >>> start = time.time()
@@ -2718,7 +2722,7 @@ class Edb:
         >>>           signal_list.append(net)
         >>> power_list = ["PGND"]
         >>> edb.create_cutout_multithread(signal_list=signal_list, reference_list=power_list, extent_type="Conforming")
-        >>> end_time = str((time.time() - start)/60)
+        >>> end_time = str((time.time() - start) / 60)
         >>> edb.logger.info("Total legacy cutout time in min %s", end_time)
         >>> edb.nets.plot(signal_list, None, color_by_net=True)
         >>> edb.nets.plot(power_list, None, color_by_net=True)
@@ -2977,8 +2981,8 @@ class Edb:
                     try:
                         shutil.copy(source, target)
                         self.logger.warning("aedb def file manually created.")
-                    except:
-                        pass
+                    except Exception as e:
+                        self.logger.error(f"Failed to copy {source} to {target} - {type(e).__name__}: {str(e)}")
         return [[pt.X.ToDouble(), pt.Y.ToDouble()] for pt in list(polygonData.GetPolygonWithoutArcs().Points)]
 
     def create_cutout_on_point_list(
@@ -3107,7 +3111,7 @@ class Edb:
         >>> from pyedb import Edb
         >>> edb = Edb(edbpath="C:\\temp\\myproject.aedb", version="2023.2")
 
-        >>> options_config = {'UNITE_NETS' : 1, 'LAUNCH_Q3D' : 0}
+        >>> options_config = {"UNITE_NETS": 1, "LAUNCH_Q3D": 0}
         >>> edb.write_export3d_option_config_file(r"C:\\temp", options_config)
         >>> edb.export_hfss(r"C:\\temp")
         """
@@ -3149,7 +3153,7 @@ class Edb:
 
         >>> from pyedb import Edb
         >>> edb = Edb(edbpath="C:\\temp\\myproject.aedb", version="2021.2")
-        >>> options_config = {'UNITE_NETS' : 1, 'LAUNCH_Q3D' : 0}
+        >>> options_config = {"UNITE_NETS": 1, "LAUNCH_Q3D": 0}
         >>> edb.write_export3d_option_config_file("C:\\temp", options_config)
         >>> edb.export_q3d("C:\\temp")
         """
@@ -3201,7 +3205,7 @@ class Edb:
 
         >>> edb = Edb(edbpath="C:\\temp\\myproject.aedb", version="2021.2")
 
-        >>> options_config = {'UNITE_NETS' : 1, 'LAUNCH_Q3D' : 0}
+        >>> options_config = {"UNITE_NETS": 1, "LAUNCH_Q3D": 0}
         >>> edb.write_export3d_option_config_file("C:\\temp", options_config)
         >>> edb.export_maxwell("C:\\temp")
         """
@@ -3369,8 +3373,8 @@ class Edb:
         >>> from pyedb import Edb
         >>> edb_app = Edb()
         >>> boolean_1, ant_length = edb_app.add_project_variable("my_local_variable", "1cm")
-        >>> print(edb_app["$my_local_variable"])    #using getitem
-        >>> edb_app["$my_local_variable"] = "1cm"   #using setitem
+        >>> print(edb_app["$my_local_variable"])  # using getitem
+        >>> edb_app["$my_local_variable"] = "1cm"  # using setitem
 
         """
         if not variable_name.startswith("$"):
@@ -3408,8 +3412,8 @@ class Edb:
         >>> from pyedb import Edb
         >>> edb_app = Edb()
         >>> boolean_1, ant_length = edb_app.add_design_variable("my_local_variable", "1cm")
-        >>> print(edb_app["my_local_variable"])    #using getitem
-        >>> edb_app["my_local_variable"] = "1cm"   #using setitem
+        >>> print(edb_app["my_local_variable"])  # using getitem
+        >>> edb_app["my_local_variable"] = "1cm"  # using setitem
         >>> boolean_2, para_length = edb_app.change_design_variable_value("my_parameter", "1m", is_parameter=True
         >>> boolean_3, project_length = edb_app.change_design_variable_value("$my_project_variable", "1m")
 
@@ -3449,7 +3453,7 @@ class Edb:
         >>> edb_app = Edb()
         >>> boolean, ant_length = edb_app.add_design_variable("ant_length", "1cm")
         >>> boolean, ant_length = edb_app.change_design_variable_value("ant_length", "1m")
-        >>> print(edb_app["ant_length"])    #using getitem
+        >>> print(edb_app["ant_length"])  # using getitem
         """
         var_server = self.variable_exists(variable_name)
         if var_server[0]:
@@ -3928,11 +3932,13 @@ class Edb:
         >>> from pyedb import Edb
         >>> edbapp = Edb()
         >>> setup1 = edbapp.create_siwave_syz_setup("setup1")
-        >>> setup1.add_frequency_sweep(frequency_sweep=[
-        ...                           ["linear count", "0", "1kHz", 1],
-        ...                           ["log scale", "1kHz", "0.1GHz", 10],
-        ...                           ["linear scale", "0.1GHz", "10GHz", "0.1GHz"],
-        ...                           ])
+        >>> setup1.add_frequency_sweep(
+        ...     frequency_sweep=[
+        ...         ["linear count", "0", "1kHz", 1],
+        ...         ["log scale", "1kHz", "0.1GHz", 10],
+        ...         ["linear scale", "0.1GHz", "10GHz", "0.1GHz"],
+        ...     ]
+        ... )
         """
         if not name:
             name = generate_unique_name("Siwave_SYZ")
@@ -4033,7 +4039,7 @@ class Edb:
         edb_zones = {}
         if not self.setups:
             self.siwave.add_siwave_syz_analysis()
-            self.save_edb()
+            self.save()
         for zone_primitive in zone_primitives:
             edb_zone_path = os.path.join(
                 working_directory,
@@ -4041,7 +4047,7 @@ class Edb:
             )
             shutil.copytree(self.edbpath, edb_zone_path)
             poly_data = zone_primitive.GetPolygonData()
-            if self.version[0] >= 10:
+            if self._db.GetVersion()[0] >= 10:
                 edb_zones[edb_zone_path] = (zone_primitive.GetZoneId(), poly_data)
             elif len(zone_primitives) == len(zone_ids):
                 edb_zones[edb_zone_path] = (zone_ids[0], poly_data)
@@ -4687,8 +4693,7 @@ class Edb:
         ]
         if not polys:
             raise RuntimeWarning(
-                f"No polygon found with voids on layer {reference_layer} during model creation for "
-                f"arbitrary wave ports"
+                f"No polygon found with voids on layer {reference_layer} during model creation for arbitrary wave ports"
             )
         void_padstacks = []
         for poly in polys:
@@ -4705,7 +4710,7 @@ class Edb:
 
         if not void_padstacks:
             raise RuntimeWarning(
-                "No padstack instances found inside evaluated voids during model creation for arbitrary" "waveports"
+                "No padstack instances found inside evaluated voids during model creation for arbitrary waveports"
             )
         cloned_edb = Edb(edbpath=output_edb)
 

pyedb/exceptions.py

@@ -1,5 +1,4 @@
-"""
-"""
+""" """
 
 
 class MaterialModelException(Exception):

pyedb/extensions/create_cell_array.py

@@ -0,0 +1,408 @@
+# 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, str]] = None,
+    offset_y: Optional[Union[int, float, str]] = 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 | str, None, optional
+        Horizontal pitch (distance between cell origins).  When *None* the
+        value is derived from the outline geometry.
+    offset_y : int | float | str, 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 and not offset_y:
+        raise ValueError("If offset_x is provided, offset_y must be provided as well")
+    if offset_y and not offset_x:
+        raise ValueError("If offset_y is provided, offset_x must be provided as well")
+
+    if not offset_x and not offset_y:
+        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)
+    offset_x = edb.value(offset_x)
+    offset_y = edb.value(offset_y)
+
+    # ---------- 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,
+            corner_style=path.corner_style,
+            start_cap_style=path.end_cap1,
+            end_cap_style=path.end_cap2,
+        )
+
+    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)]
+        end_caps = path._edb_object.GetEndCapStyle()
+
+        self.edb.modeler.create_trace(
+            path_list=list(moved_path),
+            width=path.width,
+            layer_name=path.layer.name,
+            net_name=path.net.name,
+            start_cap_style=str(end_caps[1]),
+            end_cap_style=str(end_caps[2]),
+        )
+
+    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)