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

pyedb/__init__.py

@@ -37,7 +37,7 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.56.0"
+__version__ = "0.57.0"
 version = __version__
 
 #

pyedb/configuration/cfg_data.py

@@ -36,6 +36,7 @@ from pyedb.configuration.cfg_s_parameter_models import CfgSParameters
 from pyedb.configuration.cfg_setup import CfgSetups
 from pyedb.configuration.cfg_spice_models import CfgSpiceModel
 from pyedb.configuration.cfg_stackup import CfgStackup
+from pyedb.configuration.cfg_terminals import CfgTerminals
 
 
 class CfgData(object):
@@ -59,6 +60,8 @@ class CfgData(object):
 
         self.pin_groups = CfgPinGroups(self._pedb, pingroup_data=kwargs.get("pin_groups", []))
 
+        self.terminals = CfgTerminals.create(terminals=kwargs.get("terminals", []))
+
         self.ports = CfgPorts(self._pedb, ports_data=kwargs.get("ports", []))
 
         self.sources = CfgSources(self._pedb, sources_data=kwargs.get("sources", []))

pyedb/configuration/cfg_terminals.py

@@ -0,0 +1,232 @@
+from typing import List, Literal, Optional, Union
+
+from pydantic import BaseModel
+
+
+class CfgBase(BaseModel):
+    model_config = {
+        "populate_by_name": True,
+        "extra": "forbid",
+    }
+
+
+class CfgTerminal(CfgBase):
+    name: str
+    impedance: Union[float, int, str]
+    is_circuit_port: bool
+    reference_terminal: Optional[str] = None
+    amplitude: Optional[Union[float, int, str]] = 1
+    phase: Optional[Union[float, int, str]] = 0
+    terminal_to_ground: Optional[Literal["kNoGround", "kNegative", "kPositive"]] = "kNoGround"
+    boundary_type: Literal[
+        "PortBoundary",
+        "PecBoundary",
+        "RlcBoundary",
+        "kCurrentSource",
+        "kVoltageSource",
+        "kNexximGround",
+        "kNexximPort",
+        "kDcTerminal",
+        "kVoltageProbe",
+        "InvalidBoundary",
+    ]
+    hfss_type: Literal["Wave", "Gap", None]
+
+
+class CfgPadstackInstanceTerminal(CfgTerminal):
+    terminal_type: str = "padstack_instance"
+    padstack_instance: str
+    padstack_instance_id: Optional[int] = None
+    layer: Optional[Union[str, None]] = None
+
+
+class CfgPinGroupTerminal(CfgTerminal):
+    terminal_type: str = "pin_group"
+    is_circuit_port: bool = True
+    pin_group: str
+
+
+class CfgPointTerminal(CfgTerminal):
+    terminal_type: str = "point"
+    x: Union[float, int, str]
+    y: Union[float, int, str]
+    layer: str
+    net: str
+
+
+class CfgEdgeTerminal(CfgTerminal):
+    terminal_type: str = "edge"
+    name: str
+    primitive: str
+    point_on_edge_x: Union[float, int, str]
+    point_on_edge_y: Union[float, int, str]
+    horizontal_extent_factor: Union[int, str]
+    vertical_extent_factor: Union[int, str]
+    pec_launch_width: Union[int, str]
+
+
+class CfgBundleTerminal(CfgBase):
+    terminal_type: str = "bundle"
+    terminals: List[str]
+    name: str
+
+
+class CfgTerminals(CfgBase):
+    terminals: List[
+        Union[
+            CfgPadstackInstanceTerminal, CfgPinGroupTerminal, CfgPointTerminal, CfgEdgeTerminal, CfgBundleTerminal, dict
+        ]
+    ]
+
+    @classmethod
+    def create(cls, terminals: List[dict]):
+        manager = cls(terminals=[])
+        for i in terminals:
+            terminal_type = i.pop("terminal_type")
+            if terminal_type == "padstack_instance":
+                manager.add_padstack_instance_terminal(**i)
+            elif terminal_type == "pin_group":
+                manager.add_pin_group_terminal(**i)
+            elif terminal_type == "point":
+                manager.add_point_terminal(**i)
+            elif terminal_type == "edge":
+                manager.add_edge_terminal(**i)
+            elif terminal_type == "bundle":
+                manager.add_bundle_terminal(**i)
+            else:  # pragma: no cover
+                raise ValueError(f"Unknown terminal type: {terminal_type}")
+        return manager
+
+    def add_padstack_instance_terminal(
+        self,
+        padstack_instance,
+        name,
+        impedance,
+        is_circuit_port,
+        boundary_type,
+        hfss_type,
+        reference_terminal=None,
+        amplitude=1,
+        phase=0,
+        terminal_to_ground="kNoGround",
+        padstack_instance_id=None,
+        layer=None,
+    ):
+        terminal = CfgPadstackInstanceTerminal(
+            padstack_instance=padstack_instance,
+            name=name,
+            impedance=impedance,
+            is_circuit_port=is_circuit_port,
+            boundary_type=boundary_type,
+            reference_terminal=reference_terminal,
+            amplitude=amplitude,
+            phase=phase,
+            terminal_to_ground=terminal_to_ground,
+            layer=layer,
+            hfss_type=hfss_type,
+            padstack_instance_id=padstack_instance_id,
+        )
+        self.terminals.append(terminal)
+
+    def add_pin_group_terminal(
+        self,
+        pin_group,
+        name,
+        impedance,
+        boundary_type,
+        reference_terminal=None,
+        amplitude=1,
+        phase=0,
+        terminal_to_ground="kNoGround",
+    ):
+        terminal = CfgPinGroupTerminal(
+            pin_group=pin_group,
+            name=name,
+            impedance=impedance,
+            is_circuit_port=True,
+            boundary_type=boundary_type,
+            reference_terminal=reference_terminal,
+            amplitude=amplitude,
+            phase=phase,
+            terminal_to_ground=terminal_to_ground,
+            hfss_type=None,
+        )
+        self.terminals.append(terminal)
+
+    def add_point_terminal(
+        self,
+        x,
+        y,
+        layer,
+        name,
+        impedance,
+        boundary_type,
+        net,
+        reference_terminal=None,
+        amplitude=1,
+        phase=0,
+        terminal_to_ground="kNoGround",
+    ):
+        terminal = CfgPointTerminal(
+            x=x,
+            y=y,
+            layer=layer,
+            name=name,
+            impedance=impedance,
+            is_circuit_port=True,
+            boundary_type=boundary_type,
+            reference_terminal=reference_terminal,
+            amplitude=amplitude,
+            phase=phase,
+            net=net,
+            terminal_to_ground=terminal_to_ground,
+            hfss_type=None,
+        )
+        self.terminals.append(terminal)
+
+    def add_edge_terminal(
+        self,
+        name,
+        impedance,
+        is_circuit_port,
+        boundary_type,
+        primitive,
+        point_on_edge_x,
+        point_on_edge_y,
+        horizontal_extent_factor=6,
+        vertical_extent_factor=8,
+        pec_launch_width="0.02mm",
+        reference_terminal=None,
+        amplitude=1,
+        phase=0,
+        terminal_to_ground="kNoGround",
+    ):
+        terminal = CfgEdgeTerminal(
+            name=name,
+            impedance=impedance,
+            is_circuit_port=is_circuit_port,
+            boundary_type=boundary_type,
+            reference_terminal=reference_terminal,
+            amplitude=amplitude,
+            phase=phase,
+            terminal_to_ground=terminal_to_ground,
+            primitive=primitive,
+            point_on_edge_x=point_on_edge_x,
+            point_on_edge_y=point_on_edge_y,
+            horizontal_extent_factor=horizontal_extent_factor,
+            vertical_extent_factor=vertical_extent_factor,
+            pec_launch_width=pec_launch_width,
+            hfss_type="Wave",
+        )
+        self.terminals.append(terminal)
+
+    def add_bundle_terminal(
+        self,
+        terminals,
+        name,
+    ):
+        terminal = CfgBundleTerminal(
+            terminals=terminals,
+            name=name,
+        )
+        self.terminals.append(terminal)

pyedb/configuration/configuration.py

@@ -29,6 +29,8 @@ import toml
 
 from pyedb import Edb
 from pyedb.configuration.cfg_data import CfgData
+from pyedb.dotnet.database.general import convert_py_list_to_net_list
+from pyedb.misc.decorators import execution_timer
 
 
 class Configuration:
@@ -146,8 +148,9 @@ class Configuration:
         self.__apply_with_logging("Applying package definitions", self.cfg_data.package_definitions.apply)
         self.__apply_with_logging("Applying modeler", self.apply_modeler)
         self.__apply_with_logging("Placing ports", self.cfg_data.ports.apply)
+        self.apply_terminals()
         self.__apply_with_logging("Placing probes", self.cfg_data.probes.apply)
-        self.__apply_with_logging("Applying operations", self.apply_operations)
+        self.apply_operations()
 
         return True
 
@@ -433,6 +436,9 @@ class Configuration:
             setups = self.cfg_data.setups
             setups.retrieve_parameters_from_edb()
             data["setups"] = setups.to_dict()
+        if kwargs.get("terminals", False):
+            self.get_terminals()
+            data.update(self.cfg_data.terminals.model_dump(exclude_none=True))
         if kwargs.get("sources", False):
             data["sources"] = self.cfg_data.sources.get_data_from_db()
         if kwargs.get("ports", False):
@@ -472,6 +478,7 @@ class Configuration:
 
         return data
 
+    @execution_timer("Applying operations")
     def apply_operations(self):
         """Apply operations to the current design."""
         op_cutout = self.cfg_data.operations.cutout
@@ -530,6 +537,138 @@ class Configuration:
                 signal_list=signal_list,
             )
 
+    @execution_timer("Placing terminals")
+    def apply_terminals(self):
+        terminals_dict = {}
+        bungle_terminals = []
+        edge_terminals = {}
+        for cfg_terminal in self.cfg_data.terminals.terminals:
+            if cfg_terminal.terminal_type == "padstack_instance":
+                if cfg_terminal.padstack_instance_id:
+                    pds = self._pedb.layout.find_padstack_instances(
+                        instance_id=cfg_terminal.padstack_instance_id,
+                        aedt_name=None,
+                        component_name=None,
+                        component_pin_name=None,
+                    )[0]
+                else:
+                    pds = self._pedb.layout.find_padstack_instances(
+                        instance_id=None,
+                        aedt_name=cfg_terminal.padstack_instance,
+                        component_name=None,
+                        component_pin_name=None,
+                    )[0]
+                terminal = pds.create_terminal(name=cfg_terminal.name)
+
+            elif cfg_terminal.terminal_type == "pin_group":
+                pg = self._pedb.siwave.pin_groups[cfg_terminal.pin_group]
+                terminal = pg.create_terminal(name=cfg_terminal.name)
+            elif cfg_terminal.terminal_type == "point":
+                terminal = self._pedb.get_point_terminal(
+                    cfg_terminal.name, cfg_terminal.net, [cfg_terminal.x, cfg_terminal.y], cfg_terminal.layer
+                )
+            elif cfg_terminal.terminal_type == "edge":
+                pt = self._pedb.pedb_class.database.geometry.point_data.PointData.create_from_xy(
+                    self._pedb, x=cfg_terminal.point_on_edge_x, y=cfg_terminal.point_on_edge_y
+                )
+                primitive = self._pedb.layout.primitives_by_aedt_name[cfg_terminal.primitive]
+                edge = self._pedb.core.Cell.Terminal.PrimitiveEdge.Create(primitive._edb_object, pt._edb_object)
+                edge = convert_py_list_to_net_list(edge, self._pedb.core.Cell.Terminal.Edge)
+                _terminal = self._pedb.core.Cell.Terminal.EdgeTerminal.Create(
+                    primitive._edb_object.GetLayout(),
+                    primitive._edb_object.GetNet(),
+                    cfg_terminal.name,
+                    edge,
+                    isRef=False,
+                )
+                terminal = self._pedb.pedb_class.database.cell.terminal.edge_terminal.EdgeTerminal(
+                    self._pedb, _terminal
+                )
+                terminal.horizontal_extent_factor = terminal.horizontal_extent_factor
+                terminal.vertical_extent_factor = terminal.vertical_extent_factor
+                terminal.pec_launch_width = terminal.pec_launch_width
+                terminal.do_renormalize = True
+                edge_terminals[cfg_terminal.name] = terminal
+            elif cfg_terminal.terminal_type == "bundle":
+                bungle_terminals.append(cfg_terminal)
+                continue
+            else:
+                self._pedb.logger.warning(f"Terminal type {cfg_terminal.terminal_type} not supported.")
+                continue
+
+            terminal.impedance = cfg_terminal.impedance
+            terminal.is_circuit_port = cfg_terminal.is_circuit_port
+            terminal.boundary_type = cfg_terminal.boundary_type
+            terminal.source_amplitude = cfg_terminal.amplitude
+            terminal.source_phase = cfg_terminal.phase
+            terminal.terminal_to_ground = cfg_terminal.terminal_to_ground
+
+            terminals_dict[cfg_terminal.name] = cfg_terminal, terminal
+
+        for _, obj in terminals_dict.items():
+            cfg, obj = obj
+            if cfg.reference_terminal:
+                obj.reference_terminal = terminals_dict[cfg.reference_terminal][1]
+
+        for i in bungle_terminals:
+            boundle_terminal = self._pedb.pedb_class.database.cell.terminal.bundle_terminal.BundleTerminal.create(
+                self._pedb, i.name, i.terminals
+            )
+            bundle_term = boundle_terminal.terminals
+            bundle_term[0].name = i.name + ":T1"
+            bundle_term[1].mame = i.name + ":T2"
+
+    @execution_timer("Retrieving terminal information")
+    def get_terminals(self):
+        manager = self.cfg_data.terminals
+        manager.terminals = []
+        for i in self._pedb.terminals.values():
+            if i.terminal_type == "PadstackInstanceTerminal":
+                manager.add_padstack_instance_terminal(
+                    padstack_instance=i.padstack_instance.aedt_name,
+                    padstack_instance_id=i.padstack_instance.id,
+                    name=i.name,
+                    impedance=i.impedance,
+                    is_circuit_port=i.is_circuit_port,
+                    boundary_type=i.boundary_type,
+                    amplitude=i.source_amplitude,
+                    phase=i.source_phase,
+                    terminal_to_ground=i.terminal_to_ground,
+                    reference_terminal=i.reference_terminal.name if i.reference_terminal else None,
+                    hfss_type=i.hfss_type if i.hfss_type else "Wave",
+                )
+            elif i.terminal_type == "PinGroupTerminal":
+                manager.add_pin_group_terminal(
+                    pin_group=i.pin_group().name,
+                    name=i.name,
+                    impedance=i.impedance,
+                    boundary_type=i.boundary_type,
+                    reference_terminal=i.reference_terminal.name if i.reference_terminal else None,
+                    amplitude=i.source_amplitude,
+                    phase=i.source_phase,
+                    terminal_to_ground=i.terminal_to_ground,
+                )
+            elif i.terminal_type == "PointTerminal":
+                manager.add_point_terminal(
+                    x=i.location[0],
+                    y=i.location[1],
+                    layer=i.layer.name,
+                    name=i.name,
+                    impedance=i.impedance,
+                    boundary_type=i.boundary_type,
+                    reference_terminal=i.reference_terminal.name if i.reference_terminal else None,
+                    amplitude=i.source_amplitude,
+                    phase=i.source_phase,
+                    terminal_to_ground=i.terminal_to_ground,
+                    net=i.net_name,
+                )
+            elif i.terminal_type == "EdgeTerminal":
+                pass
+            elif i.terminal_type == "BundleTerminal":
+                pass
+            else:  # pragma: no cover
+                raise RuntimeError(f"Terminal type {i.terminal_type} not supported.")
+
     def export(
         self,
         file_path,
@@ -547,6 +686,7 @@ class Configuration:
         padstacks=True,
         general=True,
         variables=True,
+        terminals=False,
     ):
         """Export the configuration data from layout to a file.
 
@@ -561,9 +701,9 @@ class Configuration:
         setups : bool
             Whether to export setups or not.
         sources : bool
-            Whether to export sources or not.
+            Whether to export sources or not. Alternative to terminals.
         ports : bool
-            Whether to export ports or not.
+            Whether to export ports or not. Alternative to terminals.
         nets : bool
             Whether to export nets.
         pin_groups : bool
@@ -582,6 +722,8 @@ class Configuration:
             Whether to export general information.
         variables : bool
             Whether to export variable.
+        terminals : bool
+            Whether to export terminals. Alternative to ports and sources.
         Returns
         -------
         bool
@@ -601,6 +743,7 @@ class Configuration:
             padstacks=padstacks,
             general=general,
             variables=variables,
+            terminals=terminals,
         )
 
         file_path = file_path if isinstance(file_path, Path) else Path(file_path)

pyedb/dotnet/clr_module.py

@@ -51,8 +51,7 @@ if is_linux:  # pragma: no cover
         # TODO: Fall backing to dotnetcore2 should be removed in a near future.
         except Exception:
             warnings.warn(
-                "Unable to set .NET root and locate the runtime configuration file. "
-                "Falling back to using dotnetcore2."
+                "Unable to set .NET root and locate the runtime configuration file. Falling back to using dotnetcore2."
             )
             warnings.warn(LINUX_WARNING)
 

pyedb/dotnet/database/Variables.py

@@ -35,9 +35,12 @@ Examples
 
 """
 
-from __future__ import absolute_import  # noreorder
-from __future__ import division
+from __future__ import (
+    absolute_import,  # noreorder
+    division,
+)
 
+import ast
 import os
 import re
 import types
@@ -493,13 +496,13 @@ class VariableManager(object):
         --------
         >>> hfss = Hfss()
         >>> print(hfss.variable_manager.decompose("5mm"))
-        >>> (5.0, 'mm')
+        >>> (5.0, "mm")
         >>> hfss["v1"] = "3N"
         >>> print(hfss.variable_manager.decompose("v1"))
-        >>> (3.0, 'N')
+        >>> (3.0, "N")
         >>> hfss["v2"] = "2*v1"
         >>> print(hfss.variable_manager.decompose("v2"))
-        >>> (6.0, 'N')
+        >>> (6.0, "N")
         """
         if variable_value in self.independent_variable_names:
             val, unit = decompose_variable_value(self[variable_value].expression)
@@ -1009,8 +1012,13 @@ class VariableManager(object):
         creating the property if it does not already exist. Also make
         it read-only and hidden and add a description.
 
-        >>> aedtapp.variable_manager.set_variable(variable_name="p2", expression="10mm", readonly=True, hidden=True,
-        ...                                       description="This is the description of this variable.")
+        >>> aedtapp.variable_manager.set_variable(
+        ...     variable_name="p2",
+        ...     expression="10mm",
+        ...     readonly=True,
+        ...     hidden=True,
+        ...     description="This is the description of this variable.",
+        ... )
 
         Set the value of the project variable ``$p1`` to ``"30mm"``,
         creating the variable if it does not exist.
@@ -1073,8 +1081,8 @@ class VariableManager(object):
                     desktop_object.Undo()
                     self._logger.clear_messages()
                     return
-            except:
-                pass
+            except Exception:
+                self._logger.debug(f"Something went wrong when deleting '{variable_name}'.")
         else:
             raise Exception("Unhandled input type to the design property or project variable.")  # pragma: no cover
 
@@ -1204,8 +1212,8 @@ class VariableManager(object):
                     ]
                 )
                 return True
-            except:
-                pass
+            except Exception:
+                self._logger.debug("Failed to change desktop object property.")
         return False
 
     def delete_variable(self, var_name):  # pragma: no cover
@@ -1244,8 +1252,8 @@ class VariableManager(object):
                         ],
                     ]
                 )
-            except:  # pragma: no cover
-                pass
+            except Exception:  # pragma: no cover
+                self._logger.debug("Failed to change desktop object property.")
             else:
                 self._cleanup_variables()
                 return True
@@ -1411,8 +1419,8 @@ class Variable(object):
                 if result:
                     break
                 i += 1
-        except:
-            pass
+        except Exception:
+            self._app.logger.debug(f"Failed to set property '{prop}' value.")
 
     def _get_prop_val(self, prop):  # pragma: no cover
         if self._app.design_type == "Maxwell Circuit":
@@ -1432,8 +1440,8 @@ class Variable(object):
                 else:
                     name = "LocalVariables"
             return self._app.get_oo_object(self._aedt_obj, "{}/{}".format(name, self._variable_name)).GetPropValue(prop)
-        except:
-            pass
+        except Exception:
+            self._app.logger.debug(f"Failed to get property '{prop}' value.")
 
     @property
     def name(self):  # pragma: no cover
@@ -1642,7 +1650,7 @@ class Variable(object):
     def numeric_value(self):  # pragma: no cover
         """Numeric part of the expression as a float value."""
         if is_array(self._value):
-            return list(eval(self._value))
+            return list(ast.literal_eval(self._value))
         try:
             var_obj = self._aedt_obj.GetChildObject("Variables").GetChildObject(self._variable_name)
             val, _ = decompose_variable_value(var_obj.GetPropEvaluatedValue("EvaluatedValue"))
@@ -1708,7 +1716,7 @@ class Variable(object):
         >>> hfss = Hfss()
         >>> hfss["v1"] = "3N"
         >>> print(hfss.variable_manager["v1"].decompose("v1"))
-        >>> (3.0, 'N')
+        >>> (3.0, "N")
 
         """
         return decompose_variable_value(self.evaluated_value)
@@ -1760,9 +1768,9 @@ class Variable(object):
         >>> from pyedb.dotnet.database.Variables import Variable
 
         >>> v = Variable("10W")
-        >>> assert v.format("f") == '10.000000W'
-        >>> assert v.format("06.2f") == '010.00W'
-        >>> assert v.format("6.2f") == ' 10.00W'
+        >>> assert v.format("f") == "10.000000W"
+        >>> assert v.format("06.2f") == "010.00W"
+        >>> assert v.format("6.2f") == " 10.00W"
 
         """
         return ("{0:" + format + "}{1}").format(self.numeric_value, self._units)

pyedb/dotnet/database/cell/layout.py

@@ -23,6 +23,7 @@
 """
 This module contains these classes: `EdbLayout` and `Shape`.
 """
+
 from typing import List, Union
 
 from pyedb.dotnet.database.cell.hierarchy.component import EDBComponent
@@ -55,6 +56,8 @@ from pyedb.dotnet.database.utilities.obj_base import ObjBase
 
 
 def primitive_cast(pedb, edb_object):
+    if not hasattr(edb_object, "GetPrimitiveType"):
+        return
     if edb_object.GetPrimitiveType().ToString() == "Rectangle":
         return EdbRectangle(edb_object, pedb)
     elif edb_object.GetPrimitiveType().ToString() == "Circle":
@@ -234,7 +237,7 @@ class Layout(ObjBase):
         primitives = list(self._edb_object.Primitives)
         if len(primitives) != len(self._primitives):
             self._primitives = [primitive_cast(self._pedb, p) for p in primitives]
-        return self._primitives
+        return [p for p in self._primitives if p is not None]  # non stackup primitives are None
 
     @property
     def primitives_by_aedt_name(self) -> dict:
@@ -406,6 +409,7 @@ class Layout(ObjBase):
         """
         candidates = self.padstack_instances
         if instance_id is not None:
+            instance_id = int(instance_id)
             value = instance_id if isinstance(instance_id, list) else [instance_id]
             candidates = [i for i in candidates if i.id in value]
 

pyedb/dotnet/database/cell/primitive/primitive.py

@@ -39,8 +39,8 @@ class Primitive(Connectable):
     >>> from pyedb import Edb
     >>> edb = Edb(myedb, edbversion="2021.2")
     >>> edb_prim = edb.modeler.primitives[0]
-    >>> edb_prim.is_void # Class Property
-    >>> edb_prim.IsVoid() # EDB Object Property
+    >>> edb_prim.is_void  # Class Property
+    >>> edb_prim.IsVoid()  # EDB Object Property
     """
 
     def __init__(self, pedb, edb_object):

pyedb/dotnet/database/cell/terminal/bundle_terminal.py

@@ -22,6 +22,7 @@
 
 from pyedb.dotnet.database.cell.terminal.edge_terminal import EdgeTerminal
 from pyedb.dotnet.database.cell.terminal.terminal import Terminal
+from pyedb.dotnet.database.general import convert_py_list_to_net_list
 
 
 class BundleTerminal(Terminal):
@@ -46,3 +47,14 @@ class BundleTerminal(Terminal):
     def decouple(self):
         """Ungroup a bundle of terminals."""
         return self._edb_object.Ungroup()
+
+    @classmethod
+    def create(cls, pedb, name, terminals):
+        terminal_list = [pedb.terminals[i]._edb_object for i in terminals]
+        edb_list = convert_py_list_to_net_list(terminal_list, pedb._edb.Cell.Terminal.Terminal)
+        _edb_boundle_terminal = pedb._edb.Cell.Terminal.BundleTerminal.Create(edb_list)
+        _edb_boundle_terminal.SetName(name)
+        pos, neg = list(_edb_boundle_terminal.GetTerminals())
+        pos.SetName(name + ":T1")
+        neg.SetName(name + ":T2")
+        return pedb.terminals[name]