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

pyedb/extensions/create_cell_array.py

@@ -23,21 +23,25 @@
 """
 This module contains the array building feature from unit cell.
 """
+
 import itertools
 from typing import Optional, Union
+import warnings
 
 from pyedb import Edb
+from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
+from pyedb.misc.decorators import execution_timer
 
 
 # ----------------------
-# Public façade function
+# Public api
 # ----------------------
 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,
+    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.
@@ -56,10 +60,10 @@ def create_array_from_unit_cell(
         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
+    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 | None, optional
+    offset_y : int | float | str, None, optional
         Vertical pitch (distance between cell origins).  When *None* the
         value is derived from the outline geometry.
 
@@ -93,12 +97,15 @@ def create_array_from_unit_cell(
         adapter = _GrpcAdapter(edb)
     else:
         adapter = _DotNetAdapter(edb)
+        warnings.warn(".NET back-end is deprecated and will be removed in future releases.", UserWarning)
+        warnings.warn("Consider moving to PyEDB gRPC (ANSYS 2025R2) for better performances", UserWarning)
     return __create_array_from_unit_cell_impl(edb, adapter, x_number, y_number, offset_x, offset_y)
 
 
 # ------------------------------------------------------------------
 # Implementation (technology-agnostic)
 # ------------------------------------------------------------------
+@execution_timer("create_array_from_unit_cell")
 def __create_array_from_unit_cell_impl(
     edb: Edb,
     adapter: "_BaseAdapter",
@@ -133,8 +140,12 @@ def __create_array_from_unit_cell_impl(
     # ---------- 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 offset_x is None or offset_y is None:
+    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:
@@ -143,40 +154,52 @@ def __create_array_from_unit_cell_impl(
         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())
+    pingroups = edb.layout.pin_groups
+    if edb.grpc:
+        pg_dict = {
+            pad.edb_uid: pg.name  # edb_uid → PinGroup.name
+            for pg in pingroups  # for every PinGroup
+            for pad in pg.pins.values()  # for every PadstackInstance in its pin-dict
+        }
+    else:
+        pg_dict = {
+            pad.id: pg.name  # edb_uid → PinGroup.name
+            for pg in pingroups  # for every PinGroup
+            for pad in pg.pins.values()  # for every PadstackInstance in its pin-dict
+        }
 
     # ---------- Replication loops ----------
     edb.logger.info(f"Starting array replication {x_number}×{y_number}")
+    total_number = x_number * y_number - 1  # minus original
+    cell_count = 0
     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)
-
+        # Components
+        for comp in components:
+            adapter.duplicate_component(comp, dx, dy, i, j, pin_groups=pg_dict)
         # 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)
-
+            if not prim.is_void:
+                adapter.duplicate_primitive(prim, dx, dy, i, j)
         # 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)
-
+        cell_count += 1
+        edb.logger.info(f"Replicated cell {cell_count} of {total_number} ({(cell_count / total_number) * 100:.1f}%)")
     edb.logger.info("Array replication finished successfully")
     return True
 
@@ -189,6 +212,8 @@ class _BaseAdapter:
 
     def __init__(self, edb: Edb):
         self.edb = edb
+        self.layers = edb.stackup.layers
+        self.active_layout = edb.active_layout
 
     # ---- Outline helpers ----
     def is_supported_outline(self, outline) -> bool:
@@ -215,10 +240,6 @@ class _BaseAdapter:
         """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
@@ -227,7 +248,7 @@ class _BaseAdapter:
         """Create a translated copy of a stand-alone via."""
         raise NotImplementedError
 
-    def duplicate_component(self, comp, dx, dy, i, j):
+    def duplicate_component(self, comp, dx, dy, i, j, pin_groups=None):
         """Create a translated copy of *comp* (including its pins)."""
         raise NotImplementedError
 
@@ -247,15 +268,11 @@ class _GrpcAdapter(_BaseAdapter):
 
     def duplicate_primitive(self, prim, dx, dy, i, j):
         moved_pd = prim.polygon_data.move((dx, dy))
+        voids = [voids.polygon_data.move((dx, dy)) for voids in prim.voids]
         return self.edb.modeler.create_polygon(
-            moved_pd,
-            layer_name=prim.layer.name,
-            net_name=prim.net.name,
+            moved_pd, layer_name=prim.layer.name, net_name=prim.net.name, voids=voids
         )
 
-    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(
@@ -263,29 +280,30 @@ class _GrpcAdapter(_BaseAdapter):
             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,
+            self.active_layout,
             net=via.net,
-            name=f"{via.name}_i{i}_j{j}",
-            padstack_def=self.edb.padstacks.definitions[via.padstack_definition],
+            name=f"{via.name}_X{i}_Y{j}",
+            padstack_def=via.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],
+            top_layer=self.layers[via.start_layer],
+            bottom_layer=self.layers[via.stop_layer],
         )
 
-    def duplicate_component(self, comp, dx, dy, i, j):
-        from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
-
+    def duplicate_component(self, comp, dx, dy, i, j, pin_groups=None):
         new_pins = []
+        _pg = {}
         for pin in comp.pins.values():
+            pg_name = pin_groups.get(pin.edb_uid, None) if pin_groups else None
             pos = pin.position
             new_pin = PadstackInstance.create(
                 self.edb.active_layout,
@@ -299,6 +317,8 @@ class _GrpcAdapter(_BaseAdapter):
                 bottom_layer=self.edb.stackup.layers[pin.stop_layer],
             )
             new_pins.append(new_pin)
+            if pg_name:
+                _pg.setdefault(pg_name, []).append(new_pin)
 
         if new_pins:
             res = self.edb.value(comp.res_value) if hasattr(comp, "res_value") and comp.res_value else None
@@ -313,8 +333,11 @@ class _GrpcAdapter(_BaseAdapter):
                 l_value=ind,
                 c_value=cap,
             )
+            new_comp.type = comp.type
             if hasattr(comp, "component_property") and comp.component_property:
                 new_comp.component_property = comp.component_property
+            for pg_name, pins in _pg.items():
+                self.edb.components.create_pingroup_from_pins(pins=pins, group_name=f"{pg_name}_{i}_{j}")
 
 
 class _DotNetAdapter(_BaseAdapter):
@@ -342,14 +365,6 @@ class _DotNetAdapter(_BaseAdapter):
             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
 
@@ -357,11 +372,15 @@ class _DotNetAdapter(_BaseAdapter):
         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):
@@ -372,7 +391,7 @@ class _DotNetAdapter(_BaseAdapter):
             via_name=f"{via.aedt_name}_i{i}_j{j}",
         )
 
-    def duplicate_component(self, comp, dx, dy, i, j):
+    def duplicate_component(self, comp, dx, dy, i, j, pin_groups=None):
         new_pins = []
         for pin in comp.pins.values():
             pos = pin.position
@@ -382,7 +401,6 @@ class _DotNetAdapter(_BaseAdapter):
                 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,

pyedb/generic/data_handlers.py

@@ -72,23 +72,13 @@ def unique_string_list(element_list, only_string=True):  # pragma: no cover
     -------
 
     """
-    if element_list:
-        if isinstance(element_list, list):
-            element_list = set(element_list)
-        elif isinstance(element_list, str):
-            element_list = [element_list]
-        else:
-            error_message = "Invalid list data"
-            try:
-                error_message += " {}".format(element_list)
-            except:
-                pass
-            raise Exception(error_message)
+    if isinstance(element_list, str):
+        element_list = [element_list]
 
-        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.")
+    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
+    return list(set(element_list))
 
 
 def string_list(element_list):  # pragma: no cover
@@ -142,28 +132,28 @@ def from_rkm(code):  # pragma: no cover
 
     Examples
     --------
-    >>> from_rkm('R47')
+    >>> from_rkm("R47")
     '0.47'
 
-    >>> from_rkm('4R7')
+    >>> from_rkm("4R7")
     '4.7'
 
-    >>> from_rkm('470R')
+    >>> from_rkm("470R")
     '470'
 
-    >>> from_rkm('4K7')
+    >>> from_rkm("4K7")
     '4.7k'
 
-    >>> from_rkm('47K')
+    >>> from_rkm("47K")
     '47k'
 
-    >>> from_rkm('47K3')
+    >>> from_rkm("47K3")
     '47.3k'
 
-    >>> from_rkm('470K')
+    >>> from_rkm("470K")
     '470k'
 
-    >>> from_rkm('4M7')
+    >>> from_rkm("4M7")
     '4.7M'
 
     """

pyedb/generic/design_types.py

@@ -32,18 +32,15 @@ if TYPE_CHECKING:
 
 
 @overload
-def Edb(*, grpc: Literal[True], **kwargs) -> "EdbGrpc":
-    ...
+def Edb(*, grpc: Literal[True], **kwargs) -> "EdbGrpc": ...
 
 
 @overload
-def Edb(*, grpc: Literal[False] = False, **kwargs) -> "EdbDotnet":
-    ...
+def Edb(*, grpc: Literal[False] = False, **kwargs) -> "EdbDotnet": ...
 
 
 @overload
-def Edb(*, grpc: bool, **kwargs) -> Union["EdbGrpc", "EdbDotnet"]:
-    ...
+def Edb(*, grpc: bool, **kwargs) -> Union["EdbGrpc", "EdbDotnet"]: ...
 
 
 # lazy imports
@@ -167,17 +164,10 @@ def Edb(
         4. Simulation Setup
 
         # Create SIwave SYZ setup
-    >>> syz_setup = edb.create_siwave_syz_setup(
-    >>> name="GHz_Setup",
-    >>> start_freq="1GHz",
-    >>> stop_freq="10GHz"
-    >>> )
+    >>> syz_setup = edb.create_siwave_syz_setup(name="GHz_Setup", start_freq="1GHz", stop_freq="10GHz")
 
         # Create SIwave DC setup
-    >>> dc_setup = edb.create_siwave_dc_setup(
-    >>> name="DC_Analysis",
-    >>> use_dc_point=True
-    >>> )
+    >>> dc_setup = edb.create_siwave_dc_setup(name="DC_Analysis", use_dc_point=True)
 
         # Solve with SIwave
     >>> edb.solve_siwave()
@@ -208,17 +198,10 @@ def Edb(
         7. Port Creation
 
         # Create wave port between two pins
-    >>> wave_port = edb.source_excitation.create_port(
-    >>> positive_terminal=pin1,
-    >>> negative_terminal=pin2,
-    >>> port_type="Wave"
-    >>> )
+    >>> wave_port = edb.source_excitation.create_port(positive_terminal=pin1, negative_terminal=pin2, port_type="Wave")
 
         # Create lumped port
-    >>> lumped_port = edb.source_excitation.create_port(
-    >>> positive_terminal=via_terminal,
-    >>> port_type="Lumped"
-    >>> )
+    >>> lumped_port = edb.source_excitation.create_port(positive_terminal=via_terminal, port_type="Lumped")
 
         8. Component Management
 
@@ -231,12 +214,7 @@ def Edb(
         9. Parametrization
 
         # Auto-parametrize design elements
-    >>> params = edb.auto_parametrize_design(
-    >>> traces=True,
-    >>> pads=True,
-    >>> antipads=True,
-    >>> use_relative_variables=True
-    >>> )
+    >>> params = edb.auto_parametrize_design(traces=True, pads=True, antipads=True, use_relative_variables=True)
     >>> print("Created parameters:", params)
 
         10. Design Statistics
@@ -255,11 +233,7 @@ def Edb(
         12. Differential Pairs
 
         # Create differential pair
-    >>> edb.differential_pairs.create(
-    >>> positive_net="USB_P",
-    >>> negative_net="USB_N",
-    >>> name="USB_DP"
-    >>> )
+    >>> edb.differential_pairs.create(positive_net="USB_P", negative_net="USB_N", name="USB_DP")
 
         13. Workflow Automation
 

pyedb/generic/filesystem.py

@@ -3,6 +3,8 @@ import secrets
 import shutil
 import string
 
+from pyedb.generic.settings import settings
+
 
 def search_files(dirname, pattern="*"):
     """Search for files inside a directory given a specific pattern.
@@ -65,8 +67,8 @@ class Scratch:
         try:
             # TODO check why on Anaconda 3.7 get errors with os.path.exists
             shutil.rmtree(self._scratch_path, ignore_errors=True)
-        except:
-            pass
+        except Exception:
+            settings.logger.error(f"An error occurred while removing {self._scratch_path}")
 
     def copyfile(self, src_file, dst_filename=None):
         """

pyedb/generic/general_methods.py

@@ -50,13 +50,9 @@ is_linux = os.name == "posix"
 is_windows = not is_linux
 _pythonver = sys.version_info[0]
 
+import xml.etree.cElementTree as ET  # nosec B405
 
-try:
-    import xml.etree.cElementTree as ET
-
-    ET.VERSION
-except ImportError:
-    ET = None
+ET.VERSION
 
 
 class GrpcApiError(Exception):
@@ -118,7 +114,6 @@ def _exception(ex_info, func, args, kwargs, message="Type Error"):
     if message_to_print:
         _write_mes("Last Electronics Desktop Message - " + message_to_print)
 
-    args_name = []
     try:
         args_dict = _get_args_dicts(func, args, kwargs)
         first_time_log = True
@@ -129,13 +124,13 @@ def _exception(ex_info, func, args, kwargs, message="Type Error"):
                     _write_mes("Method arguments: ")
                     first_time_log = False
                 _write_mes("    {} = {} ".format(el, args_dict[el]))
-    except:
-        pass
-    args = [func.__name__] + [i for i in args_name if i not in ["self"]]
+    except Exception:
+        settings.logger.error(f"An error occurred while parsing and logging an error with method {func.__name__}.")
+
     if not func.__name__.startswith("_"):
         _write_mes(
             "Check Online documentation on: https://edb.docs.pyansys.com/version/stable/search.html?q={}".format(
-                "+".join(args)
+                func.__name__
             )
         )
 
@@ -695,13 +690,9 @@ def read_csv_pandas(filename, encoding="utf-8"):  # pragma: no cover
     :class:`pandas.DataFrame`
 
     """
-    try:
-        import pandas as pd
+    import pandas as pd
 
-        return pd.read_csv(filename, encoding=encoding, header=0, na_values=".")
-    except ImportError:
-        logging.error("Pandas is not available. Install it.")
-        return None
+    return pd.read_csv(filename, encoding=encoding, header=0, na_values=".")
 
 
 def read_tab(filename):  # pragma: no cover
@@ -735,14 +726,10 @@ def read_xlsx(filename):  # pragma: no cover
     list
 
     """
-    try:
-        import pandas as pd
+    import pandas as pd
 
-        lines = pd.read_excel(filename)
-        return lines
-    except ImportError:
-        lines = []
-        return lines
+    lines = pd.read_excel(filename)
+    return lines
 
 
 def write_csv(output, list_data, delimiter=",", quotechar="|", quoting=csv.QUOTE_MINIMAL):  # pragma: no cover
@@ -872,11 +859,7 @@ def compute_fft(time_vals, value):  # pragma: no cover
     tuple
         Frequency and Values.
     """
-    try:
-        import numpy as np
-    except ImportError:
-        logging.error("NumPy is not available. Install it.")
-        return False
+    import numpy as np
 
     deltaT = time_vals[-1] - time_vals[0]
     num_points = len(time_vals)
@@ -925,11 +908,8 @@ def parse_excitation_file(
     tuple
         Frequency, magnitude and phase.
     """
-    try:
-        import numpy as np
-    except ImportError:
-        logging.error("NumPy is not available. Install it.")
-        return False
+    import numpy as np
+
     df = read_csv_pandas(file_name, encoding=encoding)
     if is_time_domain:
         time = df[df.keys()[0]].values * x_scale
@@ -1166,6 +1146,11 @@ def install_with_pip(package_name, package_path=None, upgrade=False, uninstall=F
     """Install a new package using pip.
     This method is useful for installing a package from the AEDT Console without launching the Python environment.
 
+    .. warning::
+        Do not execute this function with untrusted function argument, environment
+        variables or pyedb global settings.
+        See the :ref:`security guide<ref_security_consideration>` for details.
+
     Parameters
     ----------
     package_name : str
@@ -1178,10 +1163,12 @@ def install_with_pip(package_name, package_path=None, upgrade=False, uninstall=F
         Whether to install the package or uninstall the package.
     """
 
-    import subprocess
+    import subprocess  # nosec B404
 
-    executable = '"{}"'.format(sys.executable) if is_windows else sys.executable
+    if not package_name or not isinstance(package_name, str):
+        raise ValueError("A valid package name must be provided.")
 
+    executable = sys.executable
     commands = []
     if uninstall:
         commands.append([executable, "-m", "pip", "uninstall", "--yes", package_name])
@@ -1195,12 +1182,12 @@ def install_with_pip(package_name, package_path=None, upgrade=False, uninstall=F
             command.append("-U")
 
         commands.append(command)
+
     for command in commands:
-        if is_linux:
-            p = subprocess.Popen(command)
-        else:
-            p = subprocess.Popen(" ".join(command))
-        p.wait()
+        try:
+            subprocess.run(command, check=True)  # nosec
+        except subprocess.CalledProcessError as e:  # nosec
+            raise RuntimeError("An error occurred while installing with pip") from e
 
 
 class Help:  # pragma: no cover

pyedb/generic/plot.py

@@ -1,31 +1,16 @@
 import os
-import warnings
 
-try:
-    import numpy  # noqa: F401
-except ImportError:
-    warnings.warn(
-        "The NumPy module is required to run some functionalities of PostProcess.\n"
-        "Install with \n\npip install numpy\n\nRequires CPython."
-    )
-try:
-    from matplotlib.patches import PathPatch
-    from matplotlib.path import Path
+from matplotlib.patches import PathPatch
+from matplotlib.path import Path
+import numpy  # noqa: F401
 
-    # Use matplotlib agg backend (non-interactive) when the CI is running.
-    if bool(int(os.getenv("PYEDB_CI_NO_DISPLAY", "0"))):  # pragma: no cover
-        import matplotlib
+# Use matplotlib agg backend (non-interactive) when the CI is running.
+if bool(int(os.getenv("PYEDB_CI_NO_DISPLAY", "0"))):  # pragma: no cover
+    import matplotlib
 
-        matplotlib.use("Agg")
-    import matplotlib.pyplot as plt
+    matplotlib.use("Agg")
 
-except ImportError:
-    warnings.warn(
-        "The Matplotlib module is required to run some functionalities of PostProcess.\n"
-        "Install with \n\npip install matplotlib\n\nRequires CPython."
-    )
-except:
-    pass
+import matplotlib.pyplot as plt
 
 
 def plot_matplotlib(