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

pyedb/grpc/database/padstacks.py

@@ -25,6 +25,7 @@ This module contains the `EdbPadstacks` class.
 """
 
 from collections import defaultdict
+from functools import lru_cache
 import math
 from typing import Any, Dict, List, Optional, Tuple, Union
 import warnings
@@ -48,6 +49,29 @@ from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
 from pyedb.grpc.database.utility.value import Value
 from pyedb.modeler.geometry_operators import GeometryOperators
 
+GEOMETRY_MAP = {
+    0: GrpcPadGeometryType.PADGEOMTYPE_NO_GEOMETRY,
+    1: GrpcPadGeometryType.PADGEOMTYPE_CIRCLE,
+    2: GrpcPadGeometryType.PADGEOMTYPE_SQUARE,
+    3: GrpcPadGeometryType.PADGEOMTYPE_RECTANGLE,
+    4: GrpcPadGeometryType.PADGEOMTYPE_OVAL,
+    5: GrpcPadGeometryType.PADGEOMTYPE_BULLET,
+    6: GrpcPadGeometryType.PADGEOMTYPE_NSIDED_POLYGON,
+    7: GrpcPadGeometryType.PADGEOMTYPE_POLYGON,
+    8: GrpcPadGeometryType.PADGEOMTYPE_ROUND45,
+    9: GrpcPadGeometryType.PADGEOMTYPE_ROUND90,
+    10: GrpcPadGeometryType.PADGEOMTYPE_SQUARE45,
+    11: GrpcPadGeometryType.PADGEOMTYPE_SQUARE90,
+}
+
+PAD_TYPE_MAP = {
+    0: GrpcPadType.REGULAR_PAD,
+    1: GrpcPadType.ANTI_PAD,
+    2: GrpcPadType.THERMAL_PAD,
+    3: GrpcPadType.HOLE,
+    4: GrpcPadType.UNKNOWN_GEOM_TYPE,
+}
+
 
 class Padstacks(object):
     """Manages EDB methods for padstacks accessible from `Edb.padstacks` property.
@@ -87,6 +111,15 @@ class Padstacks(object):
     def __init__(self, p_edb: Any) -> None:
         self._pedb = p_edb
         self.__definitions: Dict[str, Any] = {}
+        self._instances = None
+        self._instances_by_name = {}
+        self._instances_by_net = {}
+
+    def clear_instances_cache(self):
+        """Clear the cached padstack instances."""
+        self._instances = None
+        self._instances_by_name = {}
+        self._instances_by_net = {}
 
     @property
     def _active_layout(self) -> Any:
@@ -113,7 +146,8 @@ class Padstacks(object):
         """ """
         return self._pedb.stackup.layers
 
-    def int_to_pad_type(self, val=0) -> GrpcPadType:
+    @staticmethod
+    def int_to_pad_type(val=0) -> GrpcPadType:
         """Convert an integer to an EDB.PadGeometryType.
 
         Parameters
@@ -131,20 +165,10 @@ class Padstacks(object):
         >>> pad_type = edb_padstacks.int_to_pad_type(1)  # Returns ANTI_PAD
         """
 
-        if val == 0:
-            return GrpcPadType.REGULAR_PAD
-        elif val == 1:
-            return GrpcPadType.ANTI_PAD
-        elif val == 2:
-            return GrpcPadType.THERMAL_PAD
-        elif val == 3:
-            return GrpcPadType.HOLE
-        elif val == 4:
-            return GrpcPadType.UNKNOWN_GEOM_TYPE
-        else:
-            return val
+        return PAD_TYPE_MAP.get(val, val)
 
-    def int_to_geometry_type(self, val: int = 0) -> GrpcPadGeometryType:
+    @staticmethod
+    def int_to_geometry_type(val: int = 0) -> GrpcPadGeometryType:
         """Convert an integer to an EDB.PadGeometryType.
 
         Parameters
@@ -161,32 +185,7 @@ class Padstacks(object):
         >>> geom_type = edb_padstacks.int_to_geometry_type(1)  # Returns CIRCLE
         >>> geom_type = edb_padstacks.int_to_geometry_type(2)  # Returns SQUARE
         """
-        if val == 0:
-            return GrpcPadGeometryType.PADGEOMTYPE_NO_GEOMETRY
-        elif val == 1:
-            return GrpcPadGeometryType.PADGEOMTYPE_CIRCLE
-        elif val == 2:
-            return GrpcPadGeometryType.PADGEOMTYPE_SQUARE
-        elif val == 3:
-            return GrpcPadGeometryType.PADGEOMTYPE_RECTANGLE
-        elif val == 4:
-            return GrpcPadGeometryType.PADGEOMTYPE_OVAL
-        elif val == 5:
-            return GrpcPadGeometryType.PADGEOMTYPE_BULLET
-        elif val == 6:
-            return GrpcPadGeometryType.PADGEOMTYPE_NSIDED_POLYGON
-        elif val == 7:
-            return GrpcPadGeometryType.PADGEOMTYPE_POLYGON
-        elif val == 8:
-            return GrpcPadGeometryType.PADGEOMTYPE_ROUND45
-        elif val == 9:
-            return GrpcPadGeometryType.PADGEOMTYPE_ROUND90
-        elif val == 10:
-            return GrpcPadGeometryType.PADGEOMTYPE_SQUARE45
-        elif val == 11:
-            return GrpcPadGeometryType.PADGEOMTYPE_SQUARE90
-        else:
-            return val
+        return GEOMETRY_MAP.get(val, val)
 
     @property
     def definitions(self) -> Dict[str, PadstackDef]:
@@ -225,7 +224,17 @@ class Padstacks(object):
         >>> for id, instance in all_instances.items():
         ...     print(f"Instance {id}: {instance.name}")
         """
-        return self._pedb.layout.padstack_instances
+        if self._instances is None:
+            self._instances = self._pedb.layout.padstack_instances
+        return self._instances
+
+    @property
+    def instances_by_net(self) -> Dict[Any, PadstackInstance]:
+        if not self._instances_by_net:
+            for edb_padstack_instance in self._instances.values():
+                if edb_padstack_instance.net_name:
+                    self._instances_by_net.setdefault(edb_padstack_instance.net_name, []).append(edb_padstack_instance)
+        return self._instances_by_net
 
     @property
     def instances_by_name(self) -> Dict[str, PadstackInstance]:
@@ -242,11 +251,11 @@ class Padstacks(object):
         >>> for name, instance in named_instances.items():
         ...     print(f"Instance named {name}")
         """
-        padstack_instances = {}
-        for _, edb_padstack_instance in self.instances.items():
-            if edb_padstack_instance.aedt_name:
-                padstack_instances[edb_padstack_instance.aedt_name] = edb_padstack_instance
-        return padstack_instances
+        if not self._instances_by_name:
+            for _, edb_padstack_instance in self.instances.items():
+                if edb_padstack_instance.aedt_name:
+                    self._instances_by_name[edb_padstack_instance.aedt_name] = edb_padstack_instance
+        return self._instances_by_name
 
     def find_instance_by_id(self, value: int) -> Optional[PadstackInstance]:
         """Find a padstack instance by database ID.
@@ -471,6 +480,7 @@ class Padstacks(object):
             if p.net_name in net_names:
                 if not p.delete():  # pragma: no cover
                     return False
+        self.clear_instances_cache()
         return True
 
     def set_solderball(self, padstackInst, sballLayer_name, isTopPlaced=True, ballDiam=100e-6):
@@ -1133,6 +1143,7 @@ class Padstacks(object):
                 layer_map=None,
             )
             padstack_instance.is_layout_pin = is_pin
+            self.clear_instances_cache()
             return PadstackInstance(self._pedb, padstack_instance)
         else:
             raise RuntimeError("Place padstack failed")
@@ -1505,7 +1516,7 @@ class Padstacks(object):
         minimum_via_number: int = 6,
         selected_angles: Optional[List[float]] = None,
         padstack_instances_id: Optional[List[int]] = None,
-    ) -> None:
+    ) -> List[str]:
         """Replace padstack instances along lines into a single polygon.
 
         Detect all pad-stack instances that are placed along lines and replace them by a single polygon based one
@@ -1594,66 +1605,13 @@ class Padstacks(object):
                 inst.delete()
         return instances_created
 
-    def reduce_via_in_bounding_box(self, bounding_box, x_samples, y_samples, nets=None):
-        """Reduces the number of vias intersecting bounding box and nets by x and y samples.
-
-        Parameters
-        ----------
-        bounding_box : tuple or list.
-            bounding box, [x1, y1, x2, y2]
-        x_samples : int
-        y_samples : int
-        nets : str or list, optional
-            net name or list of nets name applying filtering on padstack instances selection. If ``None`` is provided
-            all instances are included in the index. Default value is ``None``.
-
-        Returns
-        -------
-        bool
-            ``True`` when succeeded ``False`` when failed.
-        """
-
-        padstacks_inbox = self.get_padstack_instances_intersecting_bounding_box(bounding_box, nets)
-        if not padstacks_inbox:
-            self._logger.info("no padstack in bounding box")
-            return False
-        else:
-            if len(padstacks_inbox) <= (x_samples * y_samples):
-                self._logger.info(f"more samples {x_samples * y_samples} than existing {len(padstacks_inbox)}")
-                return False
-            else:
-                # extract ids and positions
-                vias = {item: self.instances[item].position for item in padstacks_inbox}
-                ids, positions = zip(*vias.items())
-                pt_x, pt_y = zip(*positions)
-
-                # meshgrid
-                _x_min, _x_max = min(pt_x), max(pt_x)
-                _y_min, _y_max = min(pt_y), max(pt_y)
-
-                x_grid, y_grid = np.meshgrid(
-                    np.linspace(_x_min, _x_max, x_samples), np.linspace(_y_min, _y_max, y_samples)
-                )
-
-                # mapping to meshgrid
-                to_keep = {
-                    ids[np.argmin(np.square(_x - pt_x) + np.square(_y - pt_y))]
-                    for _x, _y in zip(x_grid.ravel(), y_grid.ravel())
-                }
-
-                for item in padstacks_inbox:
-                    if item not in to_keep:
-                        self.instances[item].delete()
-
-                return True
-
     def merge_via(
         self,
         contour_boxes: List[List[float]],
         net_filter: Optional[Union[str, List[str]]] = None,
         start_layer: Optional[str] = None,
         stop_layer: Optional[str] = None,
-    ) -> bool:
+    ) -> List[str]:
         """Evaluate pad-stack instances included on the provided point list and replace all by single instance.
 
         Parameters
@@ -1673,7 +1631,6 @@ class Padstacks(object):
 
         """
 
-        import numpy as np
         from scipy.spatial import ConvexHull
 
         merged_via_ids = []
@@ -1717,6 +1674,7 @@ class Padstacks(object):
             )
             merged_via_ids.append(merged_instance.edb_uid)
             [self.instances[inst].delete() for inst in instances]
+        self.clear_instances_cache()
         return merged_via_ids
 
     def reduce_via_in_bounding_box(
@@ -1772,6 +1730,7 @@ class Padstacks(object):
                 for item in padstacks_inbox:
                     if item not in to_keep:
                         all_instances[item].delete()
+                self.clear_instances_cache()
                 return True
 
     @staticmethod
@@ -1927,5 +1886,5 @@ class Padstacks(object):
             to_delete = set(padstacks) - to_keep
             for _id in to_delete:
                 all_instances[_id].delete()
-
+        self.clear_instances_cache()
         return list(to_keep), grid

pyedb/grpc/database/primitive/padstack_instance.py

@@ -122,6 +122,47 @@ class PadstackInstance(GrpcPadstackInstance):
             term = PadstackInstanceTerminal(self._pedb, term)
         return term if not term.is_null else None
 
+    @property
+    def side_number(self):
+        """Return the number of sides meshed of the padstack instance.
+        Returns
+        -------
+        int
+            Number of sides meshed of the padstack instance.
+        """
+        side_value = self.get_product_property(GrpcProductIdType.HFSS_3D_LAYOUT, 21)
+        if side_value:
+            return int(re.search(r"(?m)^\s*sid=(\d+)", side_value).group(1))
+        return 0
+
+    @side_number.setter
+    def side_number(self, value):
+        """Set the number of sides meshed of the padstack instance.
+
+        Parameters
+        ----------
+        value : int
+            Number of sides to mesh the padstack instance.
+
+        Returns
+        -------
+        bool
+            True if successful, False otherwise.
+        """
+        if isinstance(value, int) and 3 <= value <= 64:
+            prop_string = f"$begin ''\n\tsid={value}\n\tmat='copper'\n\tvs='Wirebond'\n$end ''\n"
+            self.set_product_property(GrpcProductIdType.HFSS_3D_LAYOUT, 21, prop_string)
+        else:
+            raise ValueError("Number of sides must be an integer between 3 and 64")
+
+    def delete(self):
+        """Delete the padstack instance."""
+        try:
+            self._pedb.padstacks._instances.pop(self.edb_uid, None)
+        except Exception:
+            self._pedb.padstacks.clear_instances_cache()
+        super().delete()
+
     def set_backdrill_top(self, drill_depth, drill_diameter, offset=0.0):
         """Set backdrill from top.
 
@@ -759,18 +800,6 @@ class PadstackInstance(GrpcPadstackInstance):
     def aedt_name(self, value):
         self.set_product_property(GrpcProductIdType.DESIGNER, 11, value)
 
-    @property
-    def side_number(self) -> int:
-        if not self._side_number:
-            prop_string = "$begin ''\n\tsid=3\n\tmat='copper'\n\tvs='Wirebond'\n$end ''\n"
-            self.set_product_property(GrpcProductIdType.HFSS_3D_LAYOUT, 21, prop_string)
-        self._side_number = self.get_product_property(GrpcProductIdType.HFSS_3D_LAYOUT, 21)
-        return self._side_number
-
-    @side_number.setter
-    def side_number(self, value):
-        self._side_number = self.set_product_property(GrpcProductIdType.HFSS_3D_LAYOUT, 21, value)
-
     def split(self) -> list:
         """Split padstack instance into multiple instances. The new instances only connect adjacent layers."""
         pdef_name = self.padstack_definition

pyedb/grpc/database/primitive/path.py

@@ -25,7 +25,7 @@ from typing import Union
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
 from ansys.edb.core.primitive.path import (
     Path as GrpcPath,
-    PathCornerType as GrpcPatCornerType,
+    PathCornerType as GrpcPathCornerType,
     PathEndCapType as GrpcPathEndCapType,
 )
 
@@ -84,9 +84,9 @@ class Path(GrpcPath, Primitive):
         layer: Union[str, Layer] = None,
         net: Union[str, "Net"] = None,
         width: float = 100e-6,
-        end_cap1: str = "flat",
-        end_cap2: str = "flat",
-        corner_style: str = "sharp",
+        end_cap1: Union[str, GrpcPathEndCapType] = "flat",
+        end_cap2: Union[str, GrpcPathEndCapType] = "flat",
+        corner_style: Union[str, GrpcPathCornerType] = "sharp",
         points: Union[list, GrpcPolygonData] = None,
     ):
         """
@@ -141,9 +141,9 @@ class Path(GrpcPath, Primitive):
             "clipped": GrpcPathEndCapType.CLIPPED,
         }
         corner_style_mapping = {
-            "round": GrpcPatCornerType.ROUND,
-            "mitter": GrpcPatCornerType.MITER,
-            "sharp": GrpcPatCornerType.SHARP,
+            "round": GrpcPathCornerType.ROUND,
+            "mitter": GrpcPathCornerType.MITER,
+            "sharp": GrpcPathCornerType.SHARP,
         }
         if isinstance(end_cap1, str):
             end_cap1 = end_cap_mapping[end_cap1.lower()]
@@ -215,9 +215,9 @@ class Path(GrpcPath, Primitive):
             ``True`` when successful, ``False`` when failed.
         """
         mapping = {
-            "round": GrpcPatCornerType.ROUND,
-            "mitter": GrpcPatCornerType.MITER,
-            "sharp": GrpcPatCornerType.SHARP,
+            "round": GrpcPathCornerType.ROUND,
+            "mitter": GrpcPathCornerType.MITER,
+            "sharp": GrpcPathCornerType.SHARP,
         }
 
         cloned_path = GrpcPath.create(
@@ -444,9 +444,9 @@ class Path(GrpcPath, Primitive):
     def corner_style(self, corner_type):
         if isinstance(corner_type, str):
             mapping = {
-                "round": GrpcPatCornerType.ROUND,
-                "mitter": GrpcPatCornerType.MITER,
-                "sharp": GrpcPatCornerType.SHARP,
+                "round": GrpcPathCornerType.ROUND,
+                "mitter": GrpcPathCornerType.MITER,
+                "sharp": GrpcPathCornerType.SHARP,
             }
             self.corner_style = mapping[corner_type]
 

pyedb/grpc/database/simulation_setup/hfss_simulation_setup.py

@@ -30,6 +30,7 @@ from ansys.edb.core.simulation_setup.hfss_simulation_settings import (
 from ansys.edb.core.simulation_setup.hfss_simulation_setup import (
     HfssSimulationSetup as GrpcHfssSimulationSetup,
 )
+from ansys.edb.core.simulation_setup.mesh_operation import LengthMeshOperation as GrpcLengthMeshOperation
 
 from pyedb.generic.general_methods import generate_unique_name
 from pyedb.grpc.database.simulation_setup.sweep_data import SweepData
@@ -411,3 +412,81 @@ class HfssSimulationSetup(GrpcHfssSimulationSetup):
             else:
                 self._pedb.logger.error("Failed to add frequency sweep data")
                 return False
+
+    def auto_mesh_operation(
+        self,
+        trace_ratio_seeding: float = 3,
+        signal_via_side_number: int = 12,
+        power_ground_via_side_number: int = 6,
+    ) -> bool:
+        """
+        Automatically create and apply a length-based mesh operation for all nets in the design.
+
+        The method inspects every signal net, determines the smallest trace width, and
+        seeds a :class:`GrpcLengthMeshOperation` whose maximum element length is
+        ``smallest_width * trace_ratio_seeding``. Signal vias (padstack instances) are
+        configured with the requested number of polygon sides, while power/ground vias
+        are updated through the global ``num_via_sides`` advanced setting.
+
+        Parameters
+        ----------
+        trace_ratio_seeding : float, optional
+            Ratio used to compute the maximum allowed element length from the
+            smallest trace width found in the design.  The resulting length is
+            ``min_width * trace_ratio_seeding``.  Defaults to ``3``.
+        signal_via_side_number : int, optional
+            Number of sides (i.e. faceting resolution) assigned to **signal**
+            padstack instances that belong to the nets being meshed.
+            Defaults to ``12``.
+        power_ground_via_side_number : int, optional
+            Number of sides assigned to **power/ground** vias via the global
+            ``advanced.num_via_sides`` setting.  Defaults to ``6``.
+
+        Returns
+        -------
+        bool
+
+        Raises
+        ------
+        ValueError
+            If the design contains no terminals, making mesh seeding impossible.
+
+        Notes
+        -----
+        * Only primitives of type ``"path"`` are considered when determining the
+          smallest trace width.
+        * Every ``(net, layer, sheet)`` tuple required by the mesher is
+          automatically populated; sheet are explicitly marked as ``False``.
+        * Existing contents of :attr:`mesh_operations` are **replaced** by the
+          single new operation.
+
+        Examples
+        --------
+        >>> setup = edbapp.setups["my_setup"]
+        >>> setup.auto_mesh_operation(trace_ratio_seeding=4, signal_via_side_number=16)
+        >>> setup.mesh_operations[0].max_length
+        '2.5um'
+        """
+        net_for_mesh_seeding = list(set([term.net.name for term in list(self._pedb.terminals.values())]))
+        if not net_for_mesh_seeding:
+            raise ValueError("No terminals found to seed the mesh operation.")
+        meshop = GrpcLengthMeshOperation(name=f"{self.name}_AutoMeshOp")
+        layer_info = []
+        smallest_width = 1e3
+        for net in net_for_mesh_seeding:
+            traces = [prim for prim in self._pedb.modeler.primitives_by_net[net] if prim.type == "path"]
+            _width = min([trace.width for trace in traces], default=1e3)
+            if _width < smallest_width:
+                smallest_width = _width
+            layers = list(set([trace.layer.name for trace in traces]))
+            for layer in layers:
+                layer_info.append((net, layer, False))
+            for inst in self._pedb.padstacks.instances_by_net[net]:
+                inst.side_number = signal_via_side_number
+        meshop.max_length = f"{round(float((smallest_width * trace_ratio_seeding)), 9) * 1e6}um"
+        meshop.net_layer_info = layer_info
+        self.mesh_operations = [meshop]
+        self.settings.advanced.num_via_sides = power_ground_via_side_number
+        if self.mesh_operations:
+            return True
+        return False

pyedb/grpc/database/source_excitations.py

@@ -486,22 +486,22 @@ class SourceExcitation:
 
     def create_port_on_component(
         self,
-        component: Union[str, List[str]],
+        component: Union[str, Component],
         net_list: Union[str, List[str]],
-        port_type: SourceType,
+        port_type: str = "coax_port",
         do_pingroup: Optional[bool] = True,
         reference_net: Optional[str] = None,
         port_name: Optional[List[str]] = None,
-        solder_balls_height: Optional[float] = None,
-        solder_balls_size: Optional[float] = None,
-        solder_balls_mid_size: Optional[float] = None,
+        solder_balls_height: Union[float, str] = None,
+        solder_balls_size: Union[float, str] = None,
+        solder_balls_mid_size: Union[float, str] = None,
         extend_reference_pins_outside_component: Optional[bool] = False,
     ) -> List[str]:
         """Create ports on a component.
 
         Parameters
         ----------
-        component : str or  self._pedb.component
+        component : str or Component
             EDB component or str component name.
         net_list : str or list of string.
             List of nets where ports must be created on the component.
@@ -2661,7 +2661,7 @@ class SourceExcitation:
             for __pin in pins_name:
                 if __pin in pins:
                     pin = pins[__pin]
-                    term_name = f"{pin.component.name}_{pin.net.name}_{pin.component}"
+                    term_name = f"{pin.component.name}_{pin.net.name}_{pin.component.name}"
                     start_layer, stop_layer = pin.get_layer_range()
                     if start_layer:
                         positive_terminal = PadstackInstanceTerminal.create(

pyedb/grpc/database/stackup.py

@@ -49,6 +49,10 @@ from ansys.edb.core.layer.layer_collection import (
 )
 from ansys.edb.core.layer.stackup_layer import StackupLayer as GrpcStackupLayer
 from ansys.edb.core.layout.mcad_model import McadModel as GrpcMcadModel
+from defusedxml.ElementTree import parse as defused_parse
+import matplotlib.colors as colors
+import numpy as np
+import pandas as pd
 
 from pyedb.generic.general_methods import ET, generate_unique_name
 from pyedb.grpc.database.layers.layer import Layer
@@ -56,24 +60,6 @@ from pyedb.grpc.database.layers.stackup_layer import StackupLayer
 from pyedb.grpc.database.utility.value import Value
 from pyedb.misc.aedtlib_personalib_install import write_pretty_xml
 
-colors = None
-pd = None
-np = None
-try:
-    import matplotlib.colors as colors
-except ImportError:
-    colors = None
-
-try:
-    import numpy as np
-except ImportError:
-    np = None
-
-try:
-    import pandas as pd
-except ImportError:
-    pd = None
-
 logger = logging.getLogger(__name__)
 
 
@@ -565,9 +551,6 @@ class Stackup(LayerCollection):
         >>> edb = Edb()
         >>> edb.stackup.create_symmetric_stackup(layer_count=4)
         """
-        if not np:
-            self._pedb.logger.error("Numpy is needed. Please, install it first.")
-            return False
         if not layer_count % 2 == 0:
             return False
 
@@ -1024,10 +1007,6 @@ class Stackup(LayerCollection):
         return self.export(fpath, file_format=file_format, include_material_with_layer=include_material_with_layer)
 
     def _export_layer_stackup_to_csv_xlsx(self, fpath: Optional[str] = None, file_format: Optional[str] = None) -> bool:
-        if not pd:
-            self._pedb.logger.error("Pandas is needed. Please, install it first.")
-            return False
-
         data = {
             "Type": [],
             "Material": [],
@@ -1955,10 +1934,6 @@ class Stackup(LayerCollection):
         bool
             ``True`` when successful.
         """
-        if not pd:
-            self._pedb.logger.error("Pandas is needed. You must install it first.")
-            return False
-
         df = pd.read_csv(file_path, index_col=0)
 
         for name in self.layers.keys():  # pragma: no cover
@@ -2227,10 +2202,7 @@ class Stackup(LayerCollection):
         bool
             ``True`` when successful.
         """
-        if not colors:
-            self._pedb.logger.error("Matplotlib is needed. Please, install it first.")
-            return False
-        tree = ET.parse(file_path)
+        tree = defused_parse(file_path)
         root = tree.getroot()
         stackup = root.find("Stackup")
         stackup_dict = {}

pyedb/grpc/database/terminal/padstack_instance_terminal.py

@@ -37,16 +37,6 @@ class PadstackInstanceTerminal(GrpcPadstackInstanceTerminal):
             super().__init__(edb_object.msg)
         self._pedb = pedb
 
-    @property
-    def boundary_type(self) -> str:
-        """Boundary type.
-
-        Returns
-        -------
-        str : boundary type.
-        """
-        return super().boundary_type.name.lower()
-
     @property
     def position(self) -> list[float]:
         """Terminal position.
@@ -193,7 +183,15 @@ class PadstackInstanceTerminal(GrpcPadstackInstanceTerminal):
             "rlc": GrpcBoundaryType.RLC,
             "pec": GrpcBoundaryType.PEC,
         }
-        super(PadstackInstanceTerminal, self.__class__).boundary_type.__set__(self, mapping[value.name.lower()])
+        if isinstance(value, str):
+            key = value.lower()
+        else:
+            key = value.name.lower()
+        new_boundary_type = mapping.get(key)
+        if new_boundary_type is None:
+            valid_types = ", ".join(mapping.keys())
+            raise ValueError(f"Invalid boundary type '{value}'. Valid types are: {valid_types}")
+        super(PadstackInstanceTerminal, self.__class__).boundary_type.__set__(self, new_boundary_type)
 
     @property
     def is_port(self) -> bool: