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

pyedb/dotnet/database/Variables.py

@@ -181,13 +181,15 @@ class CSVDataset:
                 if variable in key_string:
                     found_variable = True
                     break
-            assert found_variable, "Input string {} is not a key of the data dictionary.".format(variable)
+            if not found_variable:
+                raise KeyError(f"Input string {variable} is not a key of the data dictionary.")
             data_out._data[variable] = self._data[key_string]
             data_out._header.append(variable)
         return data_out
 
     def __add__(self, other):  # pragma: no cover
-        assert self.number_of_columns == other.number_of_columns, "Inconsistent number of columns"
+        if self.number_of_columns != other.number_of_columns:
+            raise ValueError("Number of columns is inconsistent.")
         # Create a new object to return, avoiding changing the original inputs
         new_dataset = CSVDataset()
         # Add empty columns to new_dataset
@@ -222,7 +224,8 @@ class CSVDataset:
             for column in other.data:
                 self._data[column] = []
 
-        assert self.number_of_columns == other.number_of_columns, "Inconsistent number of columns"
+        if self.number_of_columns != other.number_of_columns:
+            raise ValueError("Number of columns is inconsistent.")
 
         # Append the data from 'other'
         for column, row_data in other.data.items():
@@ -1341,9 +1344,10 @@ class Variable(object):
             self._value = self._calculated_value
         # If units have been specified, check for a conflict and otherwise use the specified unit system
         if units:
-            assert not self._units, "The unit specification {} is inconsistent with the identified units {}.".format(
-                specified_units, self._units
-            )
+            if self._units and self._units != specified_units:
+                raise RuntimeError(
+                    f"The unit specification {specified_units} is inconsistent with the identified units {self._units}."
+                )
             self._units = specified_units
 
         if not si_value and is_number(self._value):
@@ -1730,9 +1734,10 @@ class Variable(object):
 
         """
         new_unit_system = unit_system(units)
-        assert (
-            new_unit_system == self.unit_system
-        ), "New unit system {0} is inconsistent with the current unit system {1}."
+        if new_unit_system != self.unit_system:
+            raise ValueError(
+                f"New unit system {new_unit_system} is inconsistent with the current unit system {self.unit_system}."
+            )
         self._units = units
         return self
 
@@ -1803,7 +1808,8 @@ class Variable(object):
         >>> assert result_3.unit_system == "Power"
 
         """
-        assert is_number(other) or isinstance(other, Variable), "Multiplier must be a scalar quantity or a variable."
+        if not is_number(other) and not isinstance(other, Variable):
+            raise ValueError("Multiplier must be a scalar quantity or a variable.")
         if is_number(other):
             result_value = self.numeric_value * other
             result_units = self.units
@@ -1847,10 +1853,10 @@ class Variable(object):
         >>> assert result.unit_system == "Current"
 
         """
-        assert isinstance(other, Variable), "You can only add a variable with another variable."
-        assert (
-            self.unit_system == other.unit_system
-        ), "Only ``Variable`` objects with the same unit system can be added."
+        if not isinstance(other, Variable):
+            raise ValueError("You can only add a variable with another variable.")
+        if self.unit_system != other.unit_system:
+            raise ValueError("Only Variable objects with the same unit system can be added.")
         result_value = self.value + other.value
         result_units = SI_UNITS[self.unit_system]
         # If the units of the two operands are different, return SI-Units
@@ -1888,10 +1894,10 @@ class Variable(object):
         >>> assert result_2.unit_system == "Current"
 
         """
-        assert isinstance(other, Variable), "You can only subtract a variable from another variable."
-        assert (
-            self.unit_system == other.unit_system
-        ), "Only ``Variable`` objects with the same unit system can be subtracted."
+        if not isinstance(other, Variable):
+            raise ValueError("You can only subtract a variable from another variable.")
+        if self.unit_system != other.unit_system:
+            raise ValueError("Only Variable objects with the same unit system can be subtracted.")
         result_value = self.value - other.value
         result_units = SI_UNITS[self.unit_system]
         # If the units of the two operands are different, return SI-Units
@@ -1933,7 +1939,8 @@ class Variable(object):
         >>> assert result_1.unit_system == "Current"
 
         """
-        assert is_number(other) or isinstance(other, Variable), "Divisor must be a scalar quantity or a variable."
+        if not is_number(other) and not isinstance(other, Variable):
+            raise ValueError("Divisor must be a scalar quantity or a variable.")
         if is_number(other):
             result_value = self.numeric_value / other
             result_units = self.units

pyedb/dotnet/database/cell/connectable.py

@@ -55,10 +55,11 @@ class Connectable(LayoutObj):
         -------
         str
         """
-        try:
-            return self._edb_object.GetNet().GetName()
-        except (KeyError, AttributeError):  # pragma: no cover
-            return None
+        net = self._edb_object.GetNet()
+        if net.IsNull():
+            return ""
+        else:
+            return net.GetName()
 
     @net_name.setter
     def net_name(self, name):
@@ -76,10 +77,38 @@ class Connectable(LayoutObj):
         -------
         :class:`dotnet.database.edb_data.nets_data.EDBComponent`
         """
-        from pyedb.dotnet.database.cell.hierarchy.component import EDBComponent
+        return self._pedb.layout.find_component_by_name(self.component_name) if self.component_name else ""
+
+    @component.setter
+    def component(self, value):
+        self._edb_object.SetGroup(self._pedb.components.instances[value]._edb_object)
 
-        edb_comp = self._edb_object.GetComponent()
-        if edb_comp.IsNull():
-            return None
+    @property
+    def component_name(self):
+        """Get the name of the component connected to this object."""
+        comp = self._edb_object.GetComponent()
+        if comp.IsNull():
+            return ""
         else:
-            return EDBComponent(self._pedb, edb_comp)
+            return comp.GetName()
+
+    def get_connected_objects(self):
+        """Get connected objects.
+
+        Returns
+        -------
+        list
+        """
+        return self._pedb.get_connected_objects(self._layout_obj_instance)
+
+    def get_connected_object_id_set(self):
+        """Produce a list of all geometries physically connected to a given layout object.
+
+        Returns
+        -------
+        list
+            Found connected objects IDs with Layout object.
+        """
+        layoutInst = self._edb_object.GetLayout().GetLayoutInstance()
+        layoutObjInst = layoutInst.GetLayoutObjInstance(self._edb_object, None)  # 2nd arg was []
+        return [loi.GetLayoutObj().GetId() for loi in layoutInst.GetConnectedObjects(layoutObjInst).Items]

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

@@ -295,7 +295,7 @@ class EDBComponent(Group):
     @solder_ball_height.setter
     def solder_ball_height(self, value):
         if "GetSolderBallProperty" in dir(self.component_property):
-            sball_height = round(self._edb.utility.Value(value).ToDouble(), 9)
+            sball_height = round(self._pedb.edb_value(value).ToDouble(), 9)
             cmp_property = self.component_property
             solder_ball_prop = cmp_property.GetSolderBallProperty().Clone()
             solder_ball_prop.SetHeight(self._get_edb_value(sball_height))
@@ -319,18 +319,18 @@ class EDBComponent(Group):
         shape = None
         if isinstance(value, str):
             if value.lower() == "cylinder":
-                shape = self._edb.definition.SolderballShape.Cylinder
+                shape = self._edb.Definition.SolderballShape.Cylinder
             elif value.lower() == "none":
-                shape = self._edb.definition.SolderballShape.NoSolderball
+                shape = self._edb.Definition.SolderballShape.NoSolderball
             elif value.lower() == "spheroid":
-                shape = self._edb.definition.SolderballShape.Spheroid
+                shape = self._edb.Definition.SolderballShape.Spheroid
         if isinstance(value, int):
             if value == 0:
-                shape = self._edb.definition.SolderballShape.NoSolderball
+                shape = self._edb.Definition.SolderballShape.NoSolderball
             elif value == 1:
-                shape = self._edb.definition.SolderballShape.Cylinder
+                shape = self._edb.Definition.SolderballShape.Cylinder
             elif value == 2:
-                shape = self._edb.definition.SolderballShape.Spheroid
+                shape = self._edb.Definition.SolderballShape.Spheroid
         if shape:
             cmp_property = self.component_property
             solder_ball_prop = cmp_property.GetSolderBallProperty().Clone()
@@ -441,11 +441,11 @@ class EDBComponent(Group):
         if isinstance(value, list):  # pragma no cover
             rlc_enabled = [True if i else False for i in value]
             rlc_values = [self._get_edb_value(i) for i in value]
-            model = self._edb.cell.hierarchy._hierarchy.PinPairModel()
+            model = self._edb.Cell.Hierarchy.PinPairModel()
             pin_names = list(self.pins.keys())
             for idx, i in enumerate(np.arange(len(pin_names) // 2)):
-                pin_pair = self._edb.utility.utility.PinPair(pin_names[idx], pin_names[idx + 1])
-                rlc = self._edb.utility.utility.Rlc(
+                pin_pair = self._edb.Utility.PinPair(pin_names[idx], pin_names[idx + 1])
+                rlc = self._edb.Utility.Rlc(
                     rlc_values[0], rlc_enabled[0], rlc_values[1], rlc_enabled[1], rlc_values[2], rlc_enabled[2], False
                 )
                 model.SetPinPairRlc(pin_pair, rlc)
@@ -482,11 +482,11 @@ class EDBComponent(Group):
         rlc_values = [value if i == self.type else 0 for i in ["Resistor", "Inductor", "Capacitor"]]
         rlc_values = [self._get_edb_value(i) for i in rlc_values]
 
-        model = self._edb.cell.hierarchy._hierarchy.PinPairModel()
+        model = self._edb.Cell.Hierarchy.PinPairModel()
         pin_names = list(self.pins.keys())
         for idx, i in enumerate(np.arange(len(pin_names) // 2)):
-            pin_pair = self._edb.utility.utility.PinPair(pin_names[idx], pin_names[idx + 1])
-            rlc = self._edb.utility.utility.Rlc(
+            pin_pair = self._edb.Utility.PinPair(pin_names[idx], pin_names[idx + 1])
+            rlc = self._edb.Utility.Rlc(
                 rlc_values[0], rlc_enabled[0], rlc_values[1], rlc_enabled[1], rlc_values[2], rlc_enabled[2], False
             )
             model.SetPinPairRlc(pin_pair, rlc)
@@ -671,7 +671,7 @@ class EDBComponent(Group):
         pins = [
             p
             for p in self.edbcomponent.LayoutObjs
-            if p.GetObjType() == self._edb.cell.layout_object_type.PadstackInstance
+            if p.GetObjType() == self._edb.Cell.LayoutObjType.PadstackInstance
             and p.IsLayoutPin()
             and p.GetComponent().GetName() == self.refdes
         ]
@@ -740,17 +740,17 @@ class EDBComponent(Group):
         """
         new_type = new_type.lower()
         if new_type == "resistor":
-            type_id = self._pedb.definition.ComponentType.Resistor
+            type_id = self._pedb.core.Definition.ComponentType.Resistor
         elif new_type == "inductor":
-            type_id = self._pedb.definition.ComponentType.Inductor
+            type_id = self._pedb.core.Definition.ComponentType.Inductor
         elif new_type == "capacitor":
-            type_id = self._pedb.definition.ComponentType.Capacitor
+            type_id = self._pedb.core.Definition.ComponentType.Capacitor
         elif new_type == "ic":
-            type_id = self._pedb.definition.ComponentType.IC
+            type_id = self._pedb.core.Definition.ComponentType.IC
         elif new_type == "io":
-            type_id = self._pedb.definition.ComponentType.IO
+            type_id = self._pedb.core.Definition.ComponentType.IO
         elif new_type == "other":
-            type_id = self._pedb.definition.ComponentType.Other
+            type_id = self._pedb.core.Definition.ComponentType.Other
         else:
             return
         self.edbcomponent.SetComponentType(type_id)
@@ -911,7 +911,7 @@ class EDBComponent(Group):
         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 = self._edb.Cell.Hierarchy.SPICEModel()
         model.SetModelPath(file_path)
         model.SetModelName(name)
         if sub_circuit_name:
@@ -949,13 +949,13 @@ class EDBComponent(Group):
             name = get_filename_without_extension(file_path)
 
         edbComponentDef = self.edbcomponent.GetComponentDef()
-        nPortModel = self._edb.definition.NPortComponentModel.FindByName(edbComponentDef, name)
+        nPortModel = self._edb.Definition.NPortComponentModel.FindByName(edbComponentDef, name)
         if nPortModel.IsNull():
-            nPortModel = self._edb.definition.NPortComponentModel.Create(name)
+            nPortModel = self._edb.Definition.NPortComponentModel.Create(name)
             nPortModel.SetReferenceFile(file_path)
             edbComponentDef.AddComponentModel(nPortModel)
 
-        model = self._edb.cell.hierarchy._hierarchy.SParameterModel()
+        model = self._edb.Cell.Hierarchy.SParameterModel()
         model.SetComponentModelName(name)
         if reference_net:
             model.SetReferenceNet(reference_net)
@@ -983,7 +983,7 @@ class EDBComponent(Group):
         >>>comp_def.add_n_port_model("c:GRM32_DC0V_25degC_series.s2p", "GRM32_DC0V_25degC_series")
         >>>edbapp.components["C200"].use_s_parameter_model("GRM32_DC0V_25degC_series")
         """
-        model = self._edb.cell.hierarchy._hierarchy.SParameterModel()
+        model = self._edb.Cell.Hierarchy.SParameterModel()
         model.SetComponentModelName(name)
         if reference_net:
             model.SetReferenceNet(reference_net)
@@ -1013,13 +1013,13 @@ class EDBComponent(Group):
         ind = 0 if ind is None else ind
         cap = 0 if cap is None else cap
         res, ind, cap = self._get_edb_value(res), self._get_edb_value(ind), self._get_edb_value(cap)
-        model = self._edb.cell.hierarchy._hierarchy.PinPairModel()
+        model = self._edb.Cell.Hierarchy.PinPairModel()
 
         pin_names = list(self.pins.keys())
         for idx, i in enumerate(np.arange(len(pin_names) // 2)):
-            pin_pair = self._edb.utility.utility.PinPair(pin_names[idx], pin_names[idx + 1])
+            pin_pair = self._edb.Utility.PinPair(pin_names[idx], pin_names[idx + 1])
 
-            rlc = self._edb.utility.utility.Rlc(res, r_enabled, ind, l_enabled, cap, c_enabled, is_parallel)
+            rlc = self._edb.Utility.Rlc(res, r_enabled, ind, l_enabled, cap, c_enabled, is_parallel)
             model.SetPinPairRlc(pin_pair, rlc)
         return self._set_model(model)
 

pyedb/dotnet/database/cell/hierarchy/model.py

@@ -28,7 +28,7 @@ class Model(ObjBase):
 
     def __init__(self, pedb, edb_object):
         super().__init__(pedb, edb_object)
-        self._model_type_mapping = {"PinPairModel": self._pedb.core.cell}
+        self._model_type_mapping = {"PinPairModel": self._pedb.core.Cell}
 
     @property
     def model_type(self):

pyedb/dotnet/database/cell/layout.py

@@ -23,7 +23,7 @@
 """
 This module contains these classes: `EdbLayout` and `Shape`.
 """
-from typing import Union
+from typing import List, Union
 
 from pyedb.dotnet.database.cell.hierarchy.component import EDBComponent
 from pyedb.dotnet.database.cell.primitive.bondwire import Bondwire
@@ -337,7 +337,7 @@ class Layout(ObjBase):
         -------
 
         """
-        obj = self._pedb._edb.Cell.Hierarchy.Component.FindByName(self._edb_object, value)
+        obj = self._pedb.core.Cell.Hierarchy.Component.FindByName(self._edb_object, value)
         return EDBComponent(self._pedb, obj) if obj is not None else None
 
     def find_primitive(
@@ -369,3 +369,64 @@ class Layout(ObjBase):
         prims = [i for i in prims if i.layer_name in layer_name] if layer_name is not None else prims
         prims = [i for i in prims if i.net_name in net_name] if net_name is not None else prims
         return prims
+
+    def find_padstack_instances(
+        self,
+        aedt_name: Union[str, List[str]] = None,
+        component_name: Union[str, List[str]] = None,
+        component_pin_name: Union[str, List[str]] = None,
+        net_name: Union[str, List[str]] = None,
+        instance_id: Union[int, List[int]] = None,
+    ) -> List:
+        """
+        Finds padstack instances matching the specified criteria.
+
+        This method filters the available padstack instances based on specified attributes such as
+        `aedt_name`, `component_name`, `component_pin_name`, `net_name`, or `instance_id`. Criteria
+        can be passed as individual values or as a list of values. If no padstack instances match
+        the criteria, an error is raised.
+
+        Parameters
+        ----------
+        aedt_name : Union[str, List[str]], optional
+            Name(s) of the AEDT padstack instance(s) to filter.
+        component_name : Union[str, List[str]], optional
+            Name(s) of the component(s) to filter padstack instances by.
+        component_pin_name : Union[str, List[str]], optional
+            Name(s) of the component pin(s) to filter padstack instances by.
+        net_name : Union[str, List[str]], optional
+            Name(s) of the net(s) to filter padstack instances by.
+        instance_id : Union[int, List[int]], optional
+            ID(s) of the padstack instance(s) to filter.
+
+        Returns
+        -------
+        List
+            A list of padstack instances matching the specified criteria.
+        """
+        candidates = self.padstack_instances
+        if instance_id is not None:
+            value = instance_id if isinstance(instance_id, list) else [instance_id]
+            candidates = [i for i in candidates if i.id in value]
+
+        if aedt_name is not None:
+            name = aedt_name if isinstance(aedt_name, list) else [aedt_name]
+            candidates = [i for i in candidates if i.aedt_name in name]
+
+        if component_name is not None:
+            value = component_name if isinstance(component_name, list) else [component_name]
+            candidates = [i for i in candidates if i.component_name in value]
+
+        if net_name is not None:
+            value = net_name if isinstance(net_name, list) else [net_name]
+            candidates = [i for i in candidates if i.net_name in value]
+
+        if component_pin_name is not None:
+            value = component_pin_name if isinstance(component_pin_name, list) else [component_pin_name]
+            candidates = [i for i in candidates if i.name in value]
+        if not candidates:  # pragma: no cover
+            raise ValueError(
+                f"Failed to find padstack instances with aedt_name={aedt_name}, component_name={component_name}, "
+                f"net_name={net_name}, component_pin_name={component_pin_name}"
+            )
+        return candidates

pyedb/dotnet/database/cell/layout_obj.py

@@ -48,12 +48,12 @@ class LayoutObj(ObjBase):
 
     @property
     def _edb_properties(self):
-        p = self._edb_object.GetProductSolverOption(self._edb.core.ProductId.Designer, "HFSS")
+        p = self._edb_object.GetProductSolverOption(self._edb.ProductId.Designer, "HFSS")
         return p
 
     @_edb_properties.setter
     def _edb_properties(self, value):
-        self._edb_object.SetProductSolverOption(self._edb.core.ProductId.Designer, "HFSS", value)
+        self._edb_object.SetProductSolverOption(self._edb.ProductId.Designer, "HFSS", value)
 
     @property
     def _obj_type(self):

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

@@ -122,7 +122,7 @@ class Path(Primitive):
             last_point = list(center_line.Points)[-1]
             x = "({})+({})".format(x, last_point.X.ToString())
             y = "({})+({})".format(y, last_point.Y.ToString())
-        center_line.AddPoint(PointData(self._pedb, x=x, y=y)._edb_object)
+        center_line.AddPoint(PointData.create_from_xy(self._pedb, x=x, y=y)._edb_object)
         return self._edb_object.SetCenterLine(center_line)
 
     def get_center_line(self, to_string=False):
@@ -151,19 +151,17 @@ class Path(Primitive):
         bool
             ``True`` when successful, ``False`` when failed.
         """
-        center_line = self.center_line
-        width = self.width
         corner_style = self.corner_style
         end_cap_style = self.get_end_cap_style()
-        cloned_path = self._app.core.cell.primitive.path.create(
+        cloned_path = self._app.core.Cell.Primitive.Path.Create(
             self._app.active_layout,
             self.layer_name,
-            self.net,
-            width,
+            self.net._edb_object,
+            self._edb_object.GetWidthValue(),
             end_cap_style[1],
             end_cap_style[2],
             corner_style,
-            center_line,
+            self._edb_object.GetCenterLine(),
         )
         if cloned_path:
             return cloned_path
@@ -338,7 +336,7 @@ class Path(Primitive):
     def center_line(self, value):
         if isinstance(value, list):
             points = [self._pedb.point_data(i[0], i[1]) for i in value]
-            polygon_data = self._edb.geometry.polygon_data.dotnetobj(convert_py_list_to_net_list(points), False)
+            polygon_data = self._edb.Geometry.PolygonData(convert_py_list_to_net_list(points), False)
             self._edb_object.SetCenterLine(polygon_data)
 
     def get_center_line_polygon_data(self):

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

@@ -21,6 +21,8 @@
 # SOFTWARE.
 import re
 
+from System import String
+
 from pyedb.dotnet.database.cell.connectable import Connectable
 from pyedb.dotnet.database.general import convert_py_list_to_net_list
 from pyedb.dotnet.database.geometry.polygon_data import PolygonData
@@ -147,15 +149,6 @@ class Primitive(Connectable):
         """
         return self._edb_object.IsVoid()
 
-    def get_connected_objects(self):
-        """Get connected objects.
-
-        Returns
-        -------
-        list
-        """
-        return self._pedb.get_connected_objects(self._layout_obj_instance)
-
     def area(self, include_voids=True):
         """Return the total area.
 
@@ -240,18 +233,6 @@ class Primitive(Connectable):
         """
         return point.IsArc()
 
-    def get_connected_object_id_set(self):
-        """Produce a list of all geometries physically connected to a given layout object.
-
-        Returns
-        -------
-        list
-            Found connected objects IDs with Layout object.
-        """
-        layoutInst = self._edb_object.GetLayout().GetLayoutInstance()
-        layoutObjInst = layoutInst.GetLayoutObjInstance(self._edb_object, None)  # 2nd arg was []
-        return [loi.GetLayoutObj().GetId() for loi in layoutInst.GetConnectedObjects(layoutObjInst).Items]
-
     @property
     def bbox(self):
         """Return the primitive bounding box points. Lower left corner, upper right corner.
@@ -540,7 +521,7 @@ class Primitive(Connectable):
         -------
         list of float
         """
-        if isinstance(point, self._app.core.geometry.geometry.PointData):
+        if isinstance(point, self._app.core.Geometry.PointData):
             point = [point.X.ToDouble(), point.Y.ToDouble()]
         dist = 1e12
         out = None
@@ -581,8 +562,6 @@ class Primitive(Connectable):
         str
             Name.
         """
-        from System import String
-
         val = String("")
 
         _, name = self._edb_object.GetProductProperty(self._pedb._edb.ProductId.Designer, 1, val)

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

@@ -45,8 +45,8 @@ class EdgeTerminal(Terminal):
             port = [port]
         temp = [self._edb_object]
         temp.extend([i._edb_object for i in port])
-        edb_list = convert_py_list_to_net_list(temp, self._edb.cell.terminal.Terminal)
-        _edb_bundle_terminal = self._edb.cell.terminal.BundleTerminal.Create(edb_list)
+        edb_list = convert_py_list_to_net_list(temp, self._edb.Cell.Terminal.Terminal)
+        _edb_bundle_terminal = self._edb.Cell.Terminal.BundleTerminal.Create(edb_list)
         return self._pedb.ports[_edb_bundle_terminal.GetName()]
 
     @property

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

@@ -80,7 +80,7 @@ class PadstackInstanceTerminal(Terminal):
 
         layer_obj = self._pedb.stackup.signal_layers[layer]
 
-        terminal = self._edb.cell.terminal.PadstackInstanceTerminal.Create(
+        terminal = self._edb.Cell.Terminal.PadstackInstanceTerminal.Create(
             self._pedb.active_layout,
             padstack_instance.net.net_object,
             name,

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

@@ -48,7 +48,7 @@ class PinGroupTerminal(Terminal):
         :class:`pyedb.dotnet.database.edb_data.terminals.PinGroupTerminal`
         """
         net_obj = self._pedb.layout.find_net_by_name(net_name)
-        term = self._pedb.core.cell.terminal.PinGroupTerminal.Create(
+        term = self._pedb.core.Cell.Terminal.PinGroupTerminal.Create(
             self._pedb.active_layout,
             net_obj._edb_object,
             name,

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

@@ -50,7 +50,7 @@ class PointTerminal(Terminal):
         -------
         :class:`pyedb.dotnet.database.edb_data.terminals.PointTerminal`
         """
-        terminal = self._pedb.core.cell.terminal.PointTerminal.Create(
+        terminal = self._pedb.core.Cell.Terminal.PointTerminal.Create(
             self._pedb.active_layout,
             self._pedb.layout.find_net_by_name(net)._edb_object,
             name,