pyedb 0.26.3__py3-none-any.whl → 0.28.0__py3-none-any.whl

pyedb/__init__.py

@@ -44,7 +44,7 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.26.3"
+__version__ = "0.28.0"
 version = __version__
 
 #

pyedb/configuration/cfg_data.py

@@ -53,7 +53,7 @@ class CfgData(object):
 
         self.components = CfgComponents(self._pedb, components_data=kwargs.get("components", []))
 
-        self.padstacks = CfgPadstacks(self, kwargs.get("padstacks", None))
+        self.padstacks = CfgPadstacks(self._pedb, kwargs.get("padstacks", None))
 
         self.pin_groups = CfgPinGroups(self._pedb, pingroup_data=kwargs.get("pin_groups", []))
 

pyedb/configuration/cfg_operations.py

@@ -65,7 +65,7 @@ class CfgCutout(CfgBase):
 
             self.reference_list = []
             self.signal_list = net_names
-        return self.export_properties()
+            return self.export_properties()
 
     def export_properties(self):
         return {
@@ -84,7 +84,7 @@ class CfgOperations(CfgBase):
         """Imports operation information from JSON."""
         if self.op_cutout:
             polygon_points = self._pedb.cutout(**self.op_cutout.get_attributes())
-            if not "pyedb_cutout" in self._pedb.stackup.all_layers:
+            if "pyedb_cutout" not in self._pedb.stackup.all_layers:
                 self._pedb.stackup.add_document_layer(name="pyedb_cutout")
                 self._pedb.modeler.create_polygon(polygon_points, layer_name="pyedb_cutout", net_name="pyedb_cutout")
 
@@ -92,4 +92,6 @@ class CfgOperations(CfgBase):
 
     def get_data_from_db(self):
         self.op_cutout = CfgCutout(self._pedb)
-        return {"cutout": self.op_cutout.get_data_from_db()}
+        data_from_db = self.op_cutout.get_data_from_db()
+        if data_from_db:
+            return {"cutout": data_from_db}

pyedb/configuration/cfg_padstacks.py

@@ -23,62 +23,69 @@
 
 from enum import Enum
 
+from pyedb.configuration.cfg_common import CfgBase
+
 
 class CfgPadstacks:
     """Padstack data class."""
 
-    def __init__(self, pdata, padstack_dict=None):
-        self._pedb = pdata._pedb
+    def __init__(self, pedb, padstack_dict=None):
+        self._pedb = pedb
         self.definitions = []
         self.instances = []
-        self._padstack_dict = padstack_dict
-        if self._padstack_dict:
-            if self._padstack_dict.get("definitions", ""):
-                self._definitions_dict = self._padstack_dict.get("definitions", "")
-                self.definitions = [Definition(pdata, definition) for definition in self._definitions_dict]
-            if self._padstack_dict.get("instances", None):
-                self._instances_dict = self._padstack_dict.get("instances", "")
-                self.instances = [Instance(pdata, inst) for inst in self._instances_dict]
+        if padstack_dict:
+            for pdef in padstack_dict.get("definitions", []):
+                self.definitions.append(Definition(**pdef))
+            for inst in padstack_dict.get("instances", []):
+                self.instances.append(Instance(self._pedb, inst))
 
     def apply(self):
         """Apply padstack definition and instances on layout."""
-        for definition in self.definitions:
-            definition.apply()
+        padstack_defs_layout = self._pedb.padstacks.definitions
+        for pdef in self.definitions:
+            pdef_layout = padstack_defs_layout[pdef.name]
+            pdef_layout.set_properties(**pdef.get_attributes())
         for instance in self.instances:
             instance.apply()
 
+    def get_data_from_db(self):
+        self.definitions = []
+        for pdef_name, pdef in self._pedb.padstacks.definitions.items():
+            self.definitions.append(
+                Definition(
+                    name=pdef_name,
+                    hole_plating_thickness=pdef.hole_plating_thickness,
+                    hole_material=pdef.material,
+                    hole_range=pdef.hole_range,
+                    pad_parameters=pdef.pad_parameters,
+                    hole_parameters=pdef.hole_parameters,
+                )
+            )
+        data = {}
+        definitions = []
+        for i in self.definitions:
+            definitions.append(i.get_attributes())
+        data["definitions"] = definitions
+        return data
+
 
-class Definition:
+class Definition(CfgBase):
     """Padstack definition data class."""
 
-    def __init__(self, pdata, definition_dict):
-        self._pedb = pdata._pedb
-        self._definition_dict = definition_dict
-        self.name = self._definition_dict.get("name", None)
-        self.hole_diameter = self._definition_dict.get("hole_diameter", None)
-        self.hole_plating_thickness = self._definition_dict.get("hole_plating_thickness", None)
-        self.hole_material = self._definition_dict.get("hole_material", None)
-        self.hole_range = self._definition_dict.get("hole_range", None)
-
-    def apply(self):
-        """Apply padstack definition on layout."""
-        padstack_defs = self._pedb.padstacks.definitions
-        pdef = padstack_defs[self.name]
-        if self.hole_diameter:
-            pdef.hole_diameter = self.hole_diameter
-        if self.hole_plating_thickness:
-            pdef.hole_plating_thickness = self.hole_plating_thickness
-        if self.hole_material:
-            pdef.material = self.hole_material
-        if self.hole_range:
-            pdef.hole_range = self.hole_range
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name", None)
+        self.hole_plating_thickness = kwargs.get("hole_plating_thickness", None)
+        self.material = kwargs.get("hole_material", None)
+        self.hole_range = kwargs.get("hole_range", None)
+        self.pad_parameters = kwargs.get("pad_parameters", None)
+        self.hole_parameters = kwargs.get("hole_parameters", None)
 
 
 class Instance:
     """Instance data class."""
 
-    def __init__(self, pdata, instances_dict):
-        self._pedb = pdata._pedb
+    def __init__(self, pedb, instances_dict):
+        self._pedb = pedb
         self._instances_dict = instances_dict
         self.name = self._instances_dict.get("name", "")
         self.backdrill_top = None

pyedb/configuration/cfg_pin_groups.py

@@ -36,12 +36,14 @@ class CfgPinGroups:
 
     def get_data_from_db(self):
         self.pin_groups = []
-        for name, pg in self._pedb.siwave.pin_groups.items():
-            pins = [p.aedt_name for p in pg.pins.values()]
+        layout_pin_groups = self._pedb.siwave.pin_groups
+        for pg_name, pg_obj in layout_pin_groups.items():
+            pins = list(pg_obj.pins.keys())
+            refdes = list(pg_obj.pins.values())[0].component.name
             cfg_pg = CfgPinGroup(
                 self._pedb,
-                name=name,
-                reference_designator=None,
+                name=pg_name,
+                reference_designator=refdes,
                 pins=pins,
             )
             self.pin_groups.append(cfg_pg)
@@ -65,10 +67,7 @@ class CfgPinGroup(CfgBase):
     def create(self):
         """Apply pin group on layout."""
         if self.pins:
-            if self.reference_designator is None:
-                self._pedb.modeler.create_pin_group(self.name, pins_by_aedt_name=self.pins)
-            else:
-                self._pedb.siwave.create_pin_group(self.reference_designator, list(self.pins), self.name)
+            self._pedb.siwave.create_pin_group(self.reference_designator, list(self.pins), self.name)
         elif self.net:
             if self.reference_designator in self._pedb.components.instances:
                 comp = self._pedb.components.instances[self.reference_designator]

pyedb/configuration/cfg_spice_models.py

@@ -34,6 +34,7 @@ class CfgSpiceModel:
         self.sub_circuit_name = self._spice_dict.get("sub_circuit_name", "")
         self.apply_to_all = self._spice_dict.get("apply_to_all", True)
         self.components = list(self._spice_dict.get("components", []))
+        self.terminal_pairs = self._spice_dict.get("terminal_pairs", None)
 
     def apply(self):
         """Apply Spice model on layout."""
@@ -45,8 +46,8 @@ class CfgSpiceModel:
         comps = self._pedb.components.definitions[self.component_definition].components
         if self.apply_to_all:
             for ref_des, comp in comps.items():
-                comp.assign_spice_model(fpath, self.name, self.sub_circuit_name)
+                comp.assign_spice_model(fpath, self.name, self.sub_circuit_name, self.terminal_pairs)
         else:
             for ref_des, comp in comps.items():
                 if ref_des in self.components:
-                    comp.assign_spice_model(fpath, self.name, self.sub_circuit_name)
+                    comp.assign_spice_model(fpath, self.name, self.sub_circuit_name, self.terminal_pairs)

pyedb/configuration/configuration.py

@@ -74,7 +74,7 @@ class Configuration:
                     elif config_file.endswith(".toml"):
                         data = toml.load(f)
             else:  # pragma: no cover
-                return False
+                raise RuntimeError(f"File {config_file} does not exist.")
 
         if not append:  # pragma: no cover
             self.data = {}
@@ -103,7 +103,7 @@ class Configuration:
                 self._pedb.open_edb()
         return self.cfg_data
 
-    def run(self):
+    def run(self, **kwargs):
         """Apply configuration settings to the current design"""
 
         # Configure boundary settings
@@ -134,7 +134,16 @@ class Configuration:
         self.cfg_data.setups.apply()
 
         # Configure stackup
-        self.cfg_data.stackup.apply()
+        if kwargs.get("fix_padstack_def"):
+            pedb_defs = self._pedb.padstacks.definitions
+            temp = {}
+            for name, pdef in pedb_defs.items():
+                temp[name] = pdef.get_properties()
+            self.cfg_data.stackup.apply()
+            for name, pdef_p in temp.items():
+                pedb_defs[name].set_properties(**pdef_p)
+        else:
+            self.cfg_data.stackup.apply()
 
         # Configure S-parameter
         for s_parameter_model in self.cfg_data.s_parameters:
@@ -282,6 +291,8 @@ class Configuration:
             data["pin_groups"] = self.cfg_data.pin_groups.get_data_from_db()
         if kwargs.get("operations", False):
             data["operations"] = self.cfg_data.operations.get_data_from_db()
+        if kwargs.get("padstacks", False):
+            data["padstacks"] = self.cfg_data.padstacks.get_data_from_db()
 
         return data
 

pyedb/dotnet/application/Variables.py

@@ -27,7 +27,7 @@ This module is used to create and edit design and project variables in the 3D to
 
 Examples
 --------
->>> from pyaedt import Hfss
+>>> from ansys.aedt.core import Hfss
 >>> hfss = Hfss()
 >>> hfss["$d"] = "5mm"
 >>> hfss["d"] = "5mm"
@@ -415,8 +415,8 @@ class VariableManager(object):
     Examples
     --------
 
-    >>> from pyaedt.maxwell import Maxwell3d
-    >>> from pyaedt.desktop import Desktop
+    >>> from ansys.aedt.core.maxwell import Maxwell3d
+    >>> from ansys.aedt.core.desktop import Desktop
     >>> d = Desktop()
     >>> aedtapp = Maxwell3d()
 
@@ -1765,40 +1765,42 @@ class Variable(object):
     def __mul__(self, other):  # pragma: no cover
         """Multiply the variable with a number or another variable and return a new object.
 
-                Parameters
-                ----------
-                other : numbers.Number or variable
-                    Object to be multiplied.
-
-                Returns
-                -------
-                type
-                    Variable.
-
-                Examples
-                --------
-                >>> from pyedb.dotnet.application.Variables import Variable
-
-                Multiply ``'Length1'`` by unitless ``'None'``` to obtain ``'Length'``.
-                A numerical value is also considered to be unitless.
-
-        import pyaedt.generic.constants        >>> v1 = Variable("10mm")
-                >>> v2 = Variable(3)
-                >>> result_1 = v1 * v2
-                >>> result_2 = v1 * 3
-                >>> assert result_1.numeric_value == 30.0
-                >>> assert result_1.unit_system == "Length"
-                >>> assert result_2.numeric_value == result_1.numeric_value
-                >>> assert result_2.unit_system == "Length"
-
-                Multiply voltage times current to obtain power.
-
-        import pyaedt.generic.constants        >>> v3 = Variable("3mA")
-                >>> v4 = Variable("40V")
-                >>> result_3 = v3 * v4
-                >>> assert result_3.numeric_value == 0.12
-                >>> assert result_3.units == "W"
-                >>> assert result_3.unit_system == "Power"
+        Parameters
+        ----------
+        other : numbers.Number or variable
+            Object to be multiplied.
+
+        Returns
+        -------
+        type
+            Variable.
+
+        Examples
+        --------
+        >>> from pyedb.dotnet.application.Variables import Variable
+
+        Multiply ``'Length1'`` by unitless ``'None'``` to obtain ``'Length'``.
+        A numerical value is also considered to be unitless.
+
+        >>> import ansys.aedt.core.generic.constants
+        >>> v1 = Variable("10mm")
+        >>> v2 = Variable(3)
+        >>> result_1 = v1 * v2
+        >>> result_2 = v1 * 3
+        >>> assert result_1.numeric_value == 30.0
+        >>> assert result_1.unit_system == "Length"
+        >>> assert result_2.numeric_value == result_1.numeric_value
+        >>> assert result_2.unit_system == "Length"
+
+        Multiply voltage times current to obtain power.
+
+        >>> import ansys.aedt.core.generic.constants
+        >>> v3 = Variable("3mA")
+        >>> v4 = Variable("40V")
+        >>> result_3 = v3 * v4
+        >>> assert result_3.numeric_value == 0.12
+        >>> assert result_3.units == "W"
+        >>> assert result_3.unit_system == "Power"
 
         """
         assert is_number(other) or isinstance(other, Variable), "Multiplier must be a scalar quantity or a variable."
@@ -1836,7 +1838,7 @@ class Variable(object):
         Examples
         --------
         >>> from pyedb.dotnet.application.Variables import Variable
-        >>> import pyaedt.generic.constants
+        >>> import ansys.aedt.core.generic.constants
         >>> v1 = Variable("3mA")
         >>> v2 = Variable("10A")
         >>> result = v1 + v2
@@ -1876,7 +1878,7 @@ class Variable(object):
         Examples
         --------
 
-        >>> import pyaedt.generic.constants
+        >>> import ansys.aedt.core.generic.constants
         >>> from pyedb.dotnet.application.Variables import Variable
         >>> v3 = Variable("3mA")
         >>> v4 = Variable("10A")
@@ -1922,7 +1924,7 @@ class Variable(object):
         resolve the new units to ``"A"``.
 
         >>> from pyedb.dotnet.application.Variables import Variable
-        >>> import pyaedt.generic.constants
+        >>> import ansys.aedt.core.generic.constants
         >>> v1 = Variable("10W")
         >>> v2 = Variable("40V")
         >>> result = v1 / v2
@@ -1964,7 +1966,7 @@ class Variable(object):
         Divide a number by a variable with units ``"s"`` and automatically determine that
         the result is in ``"Hz"``.
 
-        >>> import pyaedt.generic.constants
+        >>> import ansys.aedt.core.generic.constants
         >>> from pyedb.dotnet.application.Variables import Variable
         >>> v = Variable("1s")
         >>> result = 3.0 / v

pyedb/dotnet/edb_core/cell/connectable.py

@@ -47,6 +47,27 @@ class Connectable(LayoutObj):
         net = self._pedb.nets[value]
         self._edb_object.SetNet(net.net_object)
 
+    @property
+    def net_name(self):
+        """Get the primitive layer name.
+
+        Returns
+        -------
+        str
+        """
+        try:
+            return self._edb_object.GetNet().GetName()
+        except (KeyError, AttributeError):  # pragma: no cover
+            return None
+
+    @net_name.setter
+    def net_name(self, name):
+        if name in self._pedb.nets.netlist:
+            obj = self._pedb.nets.nets[name].net_object
+            self._edb_object.SetNet(obj)
+        else:
+            raise ValueError(f"Net {name} not found.")
+
     @property
     def component(self):
         """Component connected to this object.

pyedb/dotnet/edb_core/cell/hierarchy/component.py

@@ -22,6 +22,7 @@
 
 import logging
 import re
+from typing import Optional
 import warnings
 
 from pyedb.dotnet.edb_core.cell.hierarchy.hierarchy_obj import Group
@@ -61,6 +62,15 @@ class EDBComponent(Group):
         self._layout_instance = None
         self._comp_instance = None
 
+    @property
+    def name(self):
+        """Name of the definition."""
+        return self._edb_object.GetName()
+
+    @name.setter
+    def name(self, value):
+        self._edb_object.SetName(value)
+
     @property
     def group_type(self):
         return self._edb_object.ToString().split(".")[-1].lower()
@@ -808,7 +818,13 @@ class EDBComponent(Group):
             return False
         return True
 
-    def assign_spice_model(self, file_path, name=None, sub_circuit_name=None):
+    def assign_spice_model(
+        self,
+        file_path: str,
+        name: Optional[str] = None,
+        sub_circuit_name: Optional[str] = None,
+        terminal_pairs: Optional[list] = None,
+    ):
         """Assign Spice model to this component.
 
         Parameters
@@ -817,6 +833,10 @@ class EDBComponent(Group):
             File path of the Spice model.
         name : str, optional
             Name of the Spice model.
+        sub_circuit_name : str, optional
+            Name of the sub circuit.
+        terminal_pairs : list, optional
+            list of terminal pairs.
 
         Returns
         -------
@@ -828,23 +848,30 @@ class EDBComponent(Group):
         with open(file_path, "r") as f:
             for line in f:
                 if "subckt" in line.lower():
-                    pinNames = [i.strip() for i in re.split(" |\t", line) if i]
-                    pinNames.remove(pinNames[0])
-                    pinNames.remove(pinNames[0])
+                    pin_names_sp = [i.strip() for i in re.split(" |\t", line) if i]
+                    pin_names_sp.remove(pin_names_sp[0])
+                    pin_names_sp.remove(pin_names_sp[0])
                     break
-        if len(pinNames) == self.numpins:
-            model = self._edb.cell.hierarchy._hierarchy.SPICEModel()
-            model.SetModelPath(file_path)
-            model.SetModelName(name)
-            if sub_circuit_name:
-                model.SetSubCkt(sub_circuit_name)
-            terminal = 1
-            for pn in pinNames:
-                model.AddTerminalPinPair(pn, str(terminal))
-                terminal += 1
-        else:  # pragma: no cover
-            logging.error("Wrong number of Pins")
-            return False
+        if not len(pin_names_sp) == self.numpins:  # pragma: no cover
+            raise ValueError(f"Pin counts doesn't match component {self.name}.")
+
+        model = self._edb.cell.hierarchy._hierarchy.SPICEModel()
+        model.SetModelPath(file_path)
+        model.SetModelName(name)
+        if sub_circuit_name:
+            model.SetSubCkt(sub_circuit_name)
+
+        if terminal_pairs:
+            terminal_pairs = terminal_pairs if isinstance(terminal_pairs[0], list) else [terminal_pairs]
+            for pair in terminal_pairs:
+                pname, pnumber = pair
+                if pname not in pin_names_sp:  # pragma: no cover
+                    raise ValueError(f"Pin name {pname} doesn't exist in {file_path}.")
+                model.AddTerminalPinPair(pname, str(pnumber))
+        else:
+            for idx, pname in enumerate(pin_names_sp):
+                model.AddTerminalPinPair(pname, str(idx + 1))
+
         return self._set_model(model)
 
     def assign_s_param_model(self, file_path, name=None, reference_net=None):
@@ -856,7 +883,8 @@ class EDBComponent(Group):
             File path of the S-parameter model.
         name : str, optional
             Name of the S-parameter model.
-
+        reference_net : str, optional
+            Name of the reference net.
         Returns
         -------
 

pyedb/dotnet/edb_core/cell/layout.py

@@ -54,6 +54,29 @@ from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 from pyedb.dotnet.edb_core.utilities.obj_base import ObjBase
 
 
+def primitive_cast(pedb, edb_object):
+    if edb_object.GetPrimitiveType().ToString() == "Rectangle":
+        return EdbRectangle(edb_object, pedb)
+    elif edb_object.GetPrimitiveType().ToString() == "Circle":
+        return EdbCircle(edb_object, pedb)
+    elif edb_object.GetPrimitiveType().ToString() == "Polygon":
+        return EdbPolygon(edb_object, pedb)
+    elif edb_object.GetPrimitiveType().ToString() == "Path":
+        return Path(pedb, edb_object)
+    elif edb_object.GetPrimitiveType().ToString() == "Bondwire":
+        return Bondwire(pedb, edb_object)
+    elif edb_object.GetPrimitiveType().ToString() == "Text":
+        return EdbText(edb_object, pedb)
+    elif edb_object.GetPrimitiveType().ToString() == "PrimitivePlugin":
+        return
+    elif edb_object.GetPrimitiveType().ToString() == "Path3D":
+        return
+    elif edb_object.GetPrimitiveType().ToString() == "BoardBendDef":
+        return
+    else:
+        return
+
+
 class Layout(ObjBase):
     def __init__(self, pedb, edb_object):
         super().__init__(pedb, edb_object)
@@ -209,7 +232,7 @@ class Layout(ObjBase):
         """
         prims = []
         for p in self._edb_object.Primitives:
-            obj = self.find_object_by_id(p.GetId())
+            obj = primitive_cast(self._pedb, p)
             prims.append(obj)
         return prims
 
@@ -285,26 +308,7 @@ class Layout(ObjBase):
             return EDBPadstackInstance(obj, self._pedb)
 
         if obj.GetObjType().ToString() == "Primitive":
-            if obj.GetPrimitiveType().ToString() == "Rectangle":
-                return EdbRectangle(obj, self._pedb)
-            elif obj.GetPrimitiveType().ToString() == "Circle":
-                return EdbCircle(obj, self._pedb)
-            elif obj.GetPrimitiveType().ToString() == "Polygon":
-                return EdbPolygon(obj, self._pedb)
-            elif obj.GetPrimitiveType().ToString() == "Path":
-                return Path(self._pedb, obj)
-            elif obj.GetPrimitiveType().ToString() == "Bondwire":
-                return Bondwire(self._pedb, obj)
-            elif obj.GetPrimitiveType().ToString() == "Text":
-                return EdbText(obj, self._pedb)
-            elif obj.GetPrimitiveType().ToString() == "PrimitivePlugin":
-                pass
-            elif obj.GetPrimitiveType().ToString() == "Path3D":
-                pass
-            elif obj.GetPrimitiveType().ToString() == "BoardBendDef":
-                pass
-            else:
-                pass
+            return primitive_cast(self._pedb, obj)
 
     def find_net_by_name(self, value: str):
         """Find a net object by name
@@ -319,7 +323,10 @@ class Layout(ObjBase):
 
         """
         obj = self._pedb._edb.Cell.Net.FindByName(self._edb_object, value)
-        return EDBNetsData(obj, self._pedb) if obj is not None else None
+        if obj.IsNull():
+            raise ValueError(f"Net {value} doesn't exist")
+        else:
+            return EDBNetsData(obj, self._pedb)
 
     def find_component_by_name(self, value: str):
         """Find a component object by name. Component name is the reference designator in layout.

pyedb/dotnet/edb_core/cell/primitive/primitive.py

@@ -89,27 +89,6 @@ class Primitive(Connectable):
         """
         return self._edb_object.GetPrimitiveType().ToString().lower()
 
-    @property
-    def net_name(self):
-        """Get the primitive net name.
-
-        Returns
-        -------
-        str
-        """
-        return self.net.name
-
-    @net_name.setter
-    def net_name(self, name):
-        if isinstance(name, str):
-            net = self._app.nets.nets[name].net_object
-            self.primitive_object.SetNet(net)
-        else:
-            try:
-                self.net = name.name
-            except:  # pragma: no cover
-                self._app.logger.error("Failed to set net name.")
-
     @property
     def layer(self):
         """Get the primitive edb layer object."""
@@ -128,7 +107,7 @@ class Primitive(Connectable):
         str
         """
         try:
-            return self.layer.name
+            return self._edb_object.GetLayer().GetName()
         except (KeyError, AttributeError):  # pragma: no cover
             return None
 

pyedb/dotnet/edb_core/cell/terminal/pingroup_terminal.py

@@ -47,10 +47,10 @@ class PinGroupTerminal(Terminal):
         -------
         :class:`pyedb.dotnet.edb_core.edb_data.terminals.PinGroupTerminal`
         """
-        net_obj = self._pedb.edb_api.cell.net.find_by_name(self._pedb.active_layout, net_name)
+        net_obj = self._pedb.layout.find_net_by_name(net_name)
         term = self._pedb.edb_api.cell.terminal.PinGroupTerminal.Create(
             self._pedb.active_layout,
-            net_obj.api_object,
+            net_obj._edb_object,
             name,
             self._pedb.siwave.pin_groups[pin_group_name]._edb_object,
             is_ref,
@@ -60,7 +60,7 @@ class PinGroupTerminal(Terminal):
             msg = f"Failed to create terminal. "
             if name in self._pedb.terminals:
                 msg += f"Terminal {name} already exists."
-            raise Exception(msg)
+            raise ValueError(msg)
         else:
             return term