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

pyedb/dotnet/database/components.py

@@ -148,7 +148,7 @@ class Components(object):
 
     @property
     def _db(self):
-        return self._pedb.active_db
+        return self._pedb._db
 
     @property
     def components(self):
@@ -199,7 +199,7 @@ class Components(object):
         Returns
         -------
         dict of :class:`EDBComponentDef`"""
-        return {l.GetName(): EDBComponentDef(self._pedb, l) for l in list(self._pedb.component_defs)}
+        return {l.GetName(): EDBComponentDef(self._pedb, l) for l in list(self._pedb.active_db.ComponentDefs)}
 
     @property
     def nport_comp_definition(self):
@@ -496,7 +496,7 @@ class Components(object):
         return cmp_list
 
     def _get_edb_pin_from_pin_name(self, cmp, pin):
-        if not isinstance(cmp, self._pedb.core.cell.hierarchy.component):
+        if not isinstance(cmp, self._pedb.core.Cell.Hierarchy.Component):
             return False
         if not isinstance(pin, str):
             pin = pin.GetName()
@@ -619,7 +619,7 @@ class Components(object):
 
         """
         if cmp is not None:
-            if not (isinstance(cmp, self._pedb.core.cell.hierarchy.component)):
+            if not (isinstance(cmp, self._pedb.core.Cell.Hierarchy.Component)):
                 cmp = self.get_component_by_name(cmp)
             cmp_prop = cmp.GetComponentProperty().Clone()
             return cmp_prop.GetSolderBallProperty().GetHeight()
@@ -709,8 +709,8 @@ class Components(object):
                     positive_pin_group,
                 )
                 negative_pin_group_term = self._create_pin_group_terminal(negative_pin_group, isref=True)
-                positive_pin_group_term.SetBoundaryType(self._edb.cell.terminal.BoundaryType.kVoltageSource)
-                negative_pin_group_term.SetBoundaryType(self._edb.cell.terminal.BoundaryType.kVoltageSource)
+                positive_pin_group_term.SetBoundaryType(self._edb.Cell.Terminal.BoundaryType.kVoltageSource)
+                negative_pin_group_term.SetBoundaryType(self._edb.Cell.Terminal.BoundaryType.kVoltageSource)
                 term_name = source.name
                 positive_pin_group_term.SetName(term_name)
                 negative_pin_group_term.SetName("{}_ref".format(term_name))
@@ -726,8 +726,8 @@ class Components(object):
                     positive_pin_group,
                 )
                 negative_pin_group_term = self._create_pin_group_terminal(negative_pin_group, isref=True)
-                positive_pin_group_term.SetBoundaryType(self._edb.cell.terminal.BoundaryType.kCurrentSource)
-                negative_pin_group_term.SetBoundaryType(self._edb.cell.terminal.BoundaryType.kCurrentSource)
+                positive_pin_group_term.SetBoundaryType(self._edb.Cell.Terminal.BoundaryType.kCurrentSource)
+                negative_pin_group_term.SetBoundaryType(self._edb.Cell.Terminal.BoundaryType.kCurrentSource)
                 term_name = source.name
                 positive_pin_group_term.SetName(term_name)
                 negative_pin_group_term.SetName("{}_ref".format(term_name))
@@ -810,17 +810,21 @@ class Components(object):
         elif isinstance(refdes, self._pedb._edb.Cell.Hierarchy.Component):
             refdes = EDBComponent(self._pedb, refdes)
         pins = self._get_pins_for_ports(pins, refdes)
-        if not pins:
-            self._logger.error("No pins found during port creation. Port is not defined.")
-            return False
+        if not pins:  # pragma: no cover
+            raise RuntimeError("No pins found during port creation. Port is not defined.")
         reference_pins = self._get_pins_for_ports(reference_pins, refdes)
         if not reference_pins:
-            self._logger.error("No reference pins found during port creation. Port is not defined.")
-            return False
+            raise RuntimeError("No reference pins found during port creation. Port is not defined.")
+        if not pins:
+            raise RuntimeWarning("No pins found during port creation. Port is not defined.")
+        if reference_pins:
+            reference_pins = self._get_pins_for_ports(reference_pins, refdes)
+            if not reference_pins:
+                raise RuntimeWarning("No reference pins found during port creation. Port is not defined.")
         if refdes and any(refdes.rlc_values):
             return self.deactivate_rlc_component(component=refdes, create_circuit_port=True)
         if not port_name:
-            port_name = f"Port_{pins[0].net_name}_{pins[0].name}".replace("-", "_")
+            port_name = f"Port_{pins[0].net_name}_{pins[0].aedt_name}".replace("-", "_")
 
         if len(pins) > 1 or pingroup_on_single_pin:
             if pec_boundary:
@@ -833,7 +837,7 @@ class Components(object):
             pin_group = self.create_pingroup_from_pins(pins, group_name)
             term = self._create_pin_group_terminal(pingroup=pin_group, term_name=port_name)
         else:
-            term = self._create_terminal(pins[0].primitive_object, term_name=port_name)
+            term = self._create_terminal(pins[0]._edb_object, term_name=port_name)
         term.SetIsCircuitPort(True)
 
         if len(reference_pins) > 1 or pingroup_on_single_pin:
@@ -848,16 +852,16 @@ class Components(object):
             ref_pin_group = self.create_pingroup_from_pins(reference_pins, ref_group_name)
             ref_term = self._create_pin_group_terminal(pingroup=ref_pin_group, term_name=port_name + "_ref")
         else:
-            ref_term = self._create_terminal(reference_pins[0].primitive_object, term_name=port_name + "_ref")
+            ref_term = self._create_terminal(reference_pins[0]._edb_object, term_name=port_name + "_ref")
         ref_term.SetIsCircuitPort(True)
 
-        term.SetImpedance(self._edb.utility.value(impedance))
+        term.SetImpedance(self._edb.Utility.Value(impedance))
         term.SetReferenceTerminal(ref_term)
         if pec_boundary:
             term.SetIsCircuitPort(False)
             ref_term.SetIsCircuitPort(False)
-            term.SetBoundaryType(self._edb.cell.terminal.BoundaryType.PecBoundary)
-            ref_term.SetBoundaryType(self._edb.cell.terminal.BoundaryType.PecBoundary)
+            term.SetBoundaryType(self._edb.Cell.Terminal.BoundaryType.PecBoundary)
+            ref_term.SetBoundaryType(self._edb.Cell.Terminal.BoundaryType.PecBoundary)
             self._logger.info(
                 f"PEC boundary created between pin {pins[0].name} and reference pin {reference_pins[0].name}"
             )
@@ -867,7 +871,9 @@ class Components(object):
     def _get_pins_for_ports(
         self, pins: Union[int, str, EDBPadstackInstance, List[Union[int, str, EDBPadstackInstance]]], comp: EDBComponent
     ) -> List[EDBPadstackInstance]:
-        if not isinstance(pins, List):
+        if not pins:
+            raise ValueError("No pins provided for port creation.")
+        elif not isinstance(pins, List):
             pins = [pins]
         result = []
         for pin in pins:
@@ -877,13 +883,15 @@ class Components(object):
                 if comp and pin in comp.pins:
                     result.append(comp.pins[pin])
                 else:
-                    p = [pp for pp in list(self._padstack.instances.values()) if pp.name == pin]
+                    p = [pp for pp in list(self._padstack.instances.values()) if pp.aedt_name == pin]
                     if p:
                         result.append(p[0])
             elif isinstance(pin, EDBPadstackInstance):
                 result.append(pin)
             elif isinstance(pin, self._edb.Cell.Primitive.PadstackInstance):
                 result.append(EDBPadstackInstance(pin, self._pedb))
+        if not result:
+            raise ValueError(f"Failed to find pins for port creation: {pins} on component {comp.name}.")
         return result
 
     def create_port_on_component(
@@ -1155,7 +1163,7 @@ class Components(object):
         for term in list(self._pedb.active_layout.Terminals):
             if term.GetName() == term_name:
                 return term
-        term = self._edb.cell.terminal.PadstackInstanceTerminal.Create(
+        term = self._edb.Cell.Terminal.PadstackInstanceTerminal.Create(
             pin.GetLayout(), pin.GetNet(), term_name, pin, from_layer
         )
         return term
@@ -1223,9 +1231,9 @@ class Components(object):
                 return False
         component_type = component.edbcomponent.GetComponentType()
         if (
-            component_type == self._edb.definition.ComponentType.Other
-            or component_type == self._edb.definition.ComponentType.IC
-            or component_type == self._edb.definition.ComponentType.IO
+            component_type == self._edb.Definition.ComponentType.Other
+            or component_type == self._edb.Definition.ComponentType.IC
+            or component_type == self._edb.Definition.ComponentType.IO
         ):
             self._logger.info("Component %s passed to deactivate is not an RLC.", component.refdes)
             return False
@@ -1273,9 +1281,9 @@ class Components(object):
                 return False
         component_type = component.edbcomponent.GetComponentType()
         if (
-            component_type == self._edb.definition.ComponentType.Other
-            or component_type == self._edb.definition.ComponentType.IC
-            or component_type == self._edb.definition.ComponentType.IO
+            component_type == self._edb.Definition.ComponentType.Other
+            or component_type == self._edb.Definition.ComponentType.IC
+            or component_type == self._edb.Definition.ComponentType.IO
         ):
             self._logger.info("Component %s passed to deactivate is not an RLC.", component.refdes)
             return False
@@ -1316,7 +1324,7 @@ class Components(object):
         pins = self.get_pin_from_component(component.refdes)
         if len(pins) == 2:  # pragma: no cover
             pin_layers = self._padstack._get_pin_layer_range(pins[0])
-            pos_pin_term = self._pedb.core.cell.terminal.PadstackInstanceTerminal.Create(
+            pos_pin_term = self._pedb.core.Cell.Terminal.PadstackInstanceTerminal.Create(
                 self._active_layout,
                 pins[0].net._edb_object,
                 f"{component.refdes}_{pins[0]._edb_object.GetName()}",
@@ -1326,7 +1334,7 @@ class Components(object):
             )
             if not pos_pin_term:  # pragma: no cover
                 return False
-            neg_pin_term = self._pedb.core.cell.terminal.PadstackInstanceTerminal.Create(
+            neg_pin_term = self._pedb.core.Cell.Terminal.PadstackInstanceTerminal.Create(
                 self._active_layout,
                 pins[1].net._edb_object,
                 f"{component.refdes}_{pins[1]._edb_object.GetName()}_ref",
@@ -1337,11 +1345,11 @@ class Components(object):
             if not neg_pin_term:  # pragma: no cover
                 return False
             if pec_boundary:
-                pos_pin_term.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.PecBoundary)
-                neg_pin_term.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.PecBoundary)
+                pos_pin_term.SetBoundaryType(self._pedb.core.Cell.Terminal.BoundaryType.PecBoundary)
+                neg_pin_term.SetBoundaryType(self._pedb.core.Cell.Terminal.BoundaryType.PecBoundary)
             else:
-                pos_pin_term.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.PortBoundary)
-                neg_pin_term.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.PortBoundary)
+                pos_pin_term.SetBoundaryType(self._pedb.core.Cell.Terminal.BoundaryType.PortBoundary)
+                neg_pin_term.SetBoundaryType(self._pedb.core.Cell.Terminal.BoundaryType.PortBoundary)
             pos_pin_term.SetName(component.refdes)
             pos_pin_term.SetReferenceTerminal(neg_pin_term)
             if circuit_ports and not pec_boundary:
@@ -1382,7 +1390,7 @@ class Components(object):
         pins = self.get_pin_from_component(component.refdes)
         if len(pins) == 2:  # pragma: no cover
             pin_layer = self._padstack._get_pin_layer_range(pins[0])[0]
-            pos_pin_term = self._pedb.core.cell.terminal.PadstackInstanceTerminal.Create(
+            pos_pin_term = self._pedb.core.Cell.Terminal.PadstackInstanceTerminal.Create(
                 self._active_layout,
                 pins[0]._edb_object.GetNet(),
                 f"{component.refdes}_{pins[0]._edb_object.GetName()}",
@@ -1392,7 +1400,7 @@ class Components(object):
             )
             if not pos_pin_term:  # pragma: no cover
                 return False
-            neg_pin_term = self._pedb.core.cell.terminal.PadstackInstanceTerminal.Create(
+            neg_pin_term = self._pedb.core.Cell.Terminal.PadstackInstanceTerminal.Create(
                 self._active_layout,
                 pins[1]._edb_object.GetNet(),
                 f"{component.refdes}_{pins[1]._edb_object.GetName()}_ref",
@@ -1402,29 +1410,29 @@ class Components(object):
             )
             if not neg_pin_term:  # pragma: no cover
                 return False
-            pos_pin_term.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.RlcBoundary)
+            pos_pin_term.SetBoundaryType(self._pedb.core.Cell.Terminal.BoundaryType.RlcBoundary)
             if not circuit_type:
                 pos_pin_term.SetIsCircuitPort(False)
             else:
                 pos_pin_term.SetIsCircuitPort(True)
             pos_pin_term.SetName(component.refdes)
-            neg_pin_term.SetBoundaryType(self._pedb.core.cell.terminal.BoundaryType.RlcBoundary)
+            neg_pin_term.SetBoundaryType(self._pedb.core.Cell.Terminal.BoundaryType.RlcBoundary)
             if not circuit_type:
                 neg_pin_term.SetIsCircuitPort(False)
             else:
                 neg_pin_term.SetIsCircuitPort(True)
             pos_pin_term.SetReferenceTerminal(neg_pin_term)
             rlc_values = component.rlc_values
-            rlc = self._edb.utility.Rlc()
+            rlc = self._edb.Utility.Rlc()
             if rlc_values[0]:
                 rlc.REnabled = True
-                rlc.R = self._edb.utility.value(rlc_values[0])
+                rlc.R = self._edb.Utility.Value(rlc_values[0])
             if rlc_values[1]:
                 rlc.LEnabled = True
-                rlc.L = self._edb.utility.value(rlc_values[1])
+                rlc.L = self._edb.Utility.Value(rlc_values[1])
             if rlc_values[2]:
                 rlc.CEnabled = True
-                rlc.C = self._edb.utility.value(rlc_values[2])
+                rlc.C = self._edb.Utility.Value(rlc_values[2])
             rlc.is_parallel = component.is_parallel_rlc
             pos_pin_term.SetRlcBoundaryParameters(rlc)
             self._logger.info("Component {} has been replaced by port".format(component.refdes))
@@ -1457,7 +1465,7 @@ class Components(object):
         for t in list(self._pedb.active_layout.Terminals):
             if t.GetName() == term_name:
                 return t
-        pingroup_term = self._edb.cell.terminal.PinGroupTerminal.Create(
+        pingroup_term = self._edb.Cell.Terminal.PinGroupTerminal.Create(
             self._active_layout, pingroup.GetNet(), term_name, pingroup, isref
         )
         if term_type == "circuit":
@@ -1481,16 +1489,16 @@ class Components(object):
 
 
         """
-        signal_layers = cmp.GetLayout().GetLayerCollection().Layers(self._edb.cell.layer_type_set.SignalLayerSet)
+        signal_layers = cmp.GetLayout().GetLayerCollection().Layers(self._edb.Cell.layer_type_set.SignalLayerSet)
         if cmp.GetPlacementLayer() == signal_layers[0]:
             return True
         else:
             return False
 
     def _getComponentDefinition(self, name, pins):
-        componentDefinition = self._pedb.core.definition.ComponentDef.FindByName(self._db, name)
+        componentDefinition = self._pedb.core.Definition.ComponentDef.FindByName(self._db, name)
         if componentDefinition.IsNull():
-            componentDefinition = self._pedb.core.definition.ComponentDef.Create(self._db, name, None)
+            componentDefinition = self._pedb.core.Definition.ComponentDef.Create(self._db, name, None)
             if componentDefinition.IsNull():
                 self._logger.error("Failed to create component definition {}".format(name))
                 return None
@@ -1499,7 +1507,7 @@ class Components(object):
                 if not pin.GetName():
                     pin.SetName(str(ind))
                 ind += 1
-                componentDefinitionPin = self._pedb.core.definition.ComponentDefPin.Create(
+                componentDefinitionPin = self._pedb.core.Definition.ComponentDefPin.Create(
                     componentDefinition, pin.GetName()
                 )
                 if componentDefinitionPin.IsNull():
@@ -1614,7 +1622,7 @@ class Components(object):
             compdef = self._getComponentDefinition(component_name, pins)
         if not compdef:
             return False
-        new_cmp = self._pedb.core.cell.hierarchy.component.Create(
+        new_cmp = self._pedb.core.Cell.Hierarchy.Component.Create(
             self._active_layout, component_name, compdef.GetName()
         )
 
@@ -1622,16 +1630,16 @@ class Components(object):
         for pin in pins:
             pin.SetIsLayoutPin(True)
             new_cmp.AddMember(pin)
-        new_cmp.SetComponentType(self._edb.definition.ComponentType.Other)
+        new_cmp.SetComponentType(self._edb.Definition.ComponentType.Other)
         if not placement_layer:
             new_cmp_layer_name = pins[0].GetPadstackDef().GetData().GetLayerNames()[0]
         else:
             new_cmp_layer_name = placement_layer
-        new_cmp_placement_layer = self._edb.cell.layer.FindByName(self._layout.layer_collection, new_cmp_layer_name)
+        new_cmp_placement_layer = self._edb.Cell.Layer.FindByName(self._layout.layer_collection, new_cmp_layer_name)
         new_cmp.SetPlacementLayer(new_cmp_placement_layer)
 
         if is_rlc and len(pins) == 2:
-            rlc = self._edb.utility.utility.Rlc()
+            rlc = self._edb.Utility.Rlc()
             rlc.IsParallel = is_parallel
             if r_value is None:
                 rlc.REnabled = False
@@ -1649,18 +1657,18 @@ class Components(object):
                 rlc.CEnabled = True
                 rlc.C = self._get_edb_value(c_value)
             if rlc.REnabled and not rlc.CEnabled and not rlc.CEnabled:
-                new_cmp.SetComponentType(self._edb.definition.ComponentType.Resistor)
+                new_cmp.SetComponentType(self._edb.Definition.ComponentType.Resistor)
             elif rlc.CEnabled and not rlc.REnabled and not rlc.LEnabled:
-                new_cmp.SetComponentType(self._edb.definition.ComponentType.Capacitor)
+                new_cmp.SetComponentType(self._edb.Definition.ComponentType.Capacitor)
             elif rlc.LEnabled and not rlc.REnabled and not rlc.CEnabled:
-                new_cmp.SetComponentType(self._edb.definition.ComponentType.Inductor)
+                new_cmp.SetComponentType(self._edb.Definition.ComponentType.Inductor)
             else:
-                new_cmp.SetComponentType(self._edb.definition.ComponentType.Resistor)
+                new_cmp.SetComponentType(self._edb.Definition.ComponentType.Resistor)
 
-            pin_pair = self._edb.utility.utility.PinPair(pins[0].GetName(), pins[1].GetName())
-            rlc_model = self._edb.cell.hierarchy._hierarchy.PinPairModel()
+            pin_pair = self._edb.Utility.PinPair(pins[0].GetName(), pins[1].GetName())
+            rlc_model = self._edb.Cell.Hierarchy.PinPairModel()
             rlc_model.SetPinPairRlc(pin_pair, rlc)
-            edb_rlc_component_property = self._edb.cell.hierarchy._hierarchy.RLCComponentProperty()
+            edb_rlc_component_property = self._edb.Cell.Hierarchy.RLCComponentProperty()
             if not edb_rlc_component_property.SetModel(rlc_model) or not new_cmp.SetComponentProperty(
                 edb_rlc_component_property
             ):
@@ -1761,7 +1769,7 @@ class Components(object):
                         pinNames.remove(pinNames[0])
                         break
             if len(pinNames) == pinNumber:
-                spiceMod = self._edb.cell.hierarchy._hierarchy.SPICEModel()
+                spiceMod = self._edb.Cell.Hierarchy.SPICEModel()
                 spiceMod.SetModelPath(modelpath)
                 spiceMod.SetModelName(modelname)
                 terminal = 1
@@ -1780,13 +1788,13 @@ class Components(object):
         elif model_type == "Touchstone":  # pragma: no cover
             nPortModelName = modelname
             edbComponentDef = edbComponent.GetComponentDef()
-            nPortModel = self._edb.definition.NPortComponentModel.FindByName(edbComponentDef, nPortModelName)
+            nPortModel = self._edb.Definition.NPortComponentModel.FindByName(edbComponentDef, nPortModelName)
             if nPortModel.IsNull():
-                nPortModel = self._edb.definition.NPortComponentModel.Create(nPortModelName)
+                nPortModel = self._edb.Definition.NPortComponentModel.Create(nPortModelName)
                 nPortModel.SetReferenceFile(modelpath)
                 edbComponentDef.AddComponentModel(nPortModel)
 
-            sParameterMod = self._edb.cell.hierarchy._hierarchy.SParameterModel()
+            sParameterMod = self._edb.Cell.Hierarchy.SParameterModel()
             sParameterMod.SetComponentModelName(nPortModelName)
             gndnets = list(filter(lambda x: "gnd" in x.lower(), componentNets))
             if len(gndnets) > 0:  # pragma: no cover
@@ -1831,7 +1839,7 @@ class Components(object):
             if _pins:
                 pins = _pins
         if group_name is None:
-            group_name = self._edb.cell.hierarchy.pin_group.GetUniqueName(self._active_layout)
+            group_name = self._edb.Cell.Hierarchy.PinGroup.GetUniqueName(self._active_layout)
         for pin in pins:
             pin.SetIsLayoutPin(True)
         forbiden_car = "-><"
@@ -1845,18 +1853,18 @@ class Components(object):
                         if p.GetName() in pnames:
                             continue
                         else:
-                            group_name = self._edb.cell.hierarchy.pin_group.GetUniqueName(
+                            group_name = self._edb.Cell.Hierarchy.PinGroup.GetUniqueName(
                                 self._active_layout, group_name
                             )
                             pin_group_exists = False
                 else:
-                    group_name = self._edb.cell.hierarchy.pin_group.GetUniqueName(self._active_layout, group_name)
+                    group_name = self._edb.Cell.Hierarchy.PinGroup.GetUniqueName(self._active_layout, group_name)
                     pin_group_exists = False
                 if pin_group_exists:
                     return pgroup
         pingroup = _retry_ntimes(
             10,
-            self._edb.cell.hierarchy.pin_group.Create,
+            self._edb.Cell.Hierarchy.PinGroup.Create,
             self._active_layout,
             group_name,
             convert_py_list_to_net_list(pins),
@@ -1904,7 +1912,7 @@ class Components(object):
                     deleted_comps.append(comp)
         if not deactivate_only:
             self.refresh_components()
-        self._pedb._logger.info("Deleted {} components".format(len(deleted_comps)))
+        self._pedb.logger.info("Deleted {} components".format(len(deleted_comps)))
 
         return deleted_comps
 
@@ -2053,7 +2061,7 @@ class Components(object):
         >>> edbapp.components.set_solder_ball("A1")
 
         """
-        if not isinstance(component, self._pedb.core.cell.hierarchy.component):
+        if not isinstance(component, self._pedb.core.Cell.Hierarchy.Component):
             edb_cmp = self.get_component_by_name(component)._edb_object
             cmp = self.instances[component]
         else:  # pragma: no cover
@@ -2065,29 +2073,29 @@ class Components(object):
             pin1 = list(cmp.pins.values())[0].pin
             pin_layers = pin1.GetPadstackDef().GetData().GetLayerNames()
             pad_params = self._padstack.get_pad_parameters(pin=pin1, layername=pin_layers[0], pad_type=0)
-            _sb_diam = min([abs(self._get_edb_value(val).ToDouble()) for val in pad_params[1]])
+            _sb_diam = min([abs(self._pedb.edb_value(val).ToDouble()) for val in pad_params[1]])
             sball_diam = 0.8 * _sb_diam
         if sball_height:
-            sball_height = round(self._edb.utility.Value(sball_height).ToDouble(), 9)
+            sball_height = round(self._pedb.edb_value(sball_height).ToDouble(), 9)
         else:
-            sball_height = round(self._edb.utility.Value(sball_diam).ToDouble(), 9) / 2
+            sball_height = round(self._pedb.edb_value(sball_diam).ToDouble(), 9) / 2
 
         if not sball_mid_diam:
             sball_mid_diam = sball_diam
 
         if shape.lower() == "cylinder":
-            sball_shape = self._edb.definition.SolderballShape.Cylinder
+            sball_shape = self._edb.Definition.SolderballShape.Cylinder
         else:
-            sball_shape = self._edb.definition.SolderballShape.Spheroid
+            sball_shape = self._edb.Definition.SolderballShape.Spheroid
 
         cmp_property = edb_cmp.GetComponentProperty().Clone()
-        if cmp_type == self._edb.definition.ComponentType.IC:
+        if cmp_type == self._edb.Definition.ComponentType.IC:
             ic_die_prop = cmp_property.GetDieProperty().Clone()
-            ic_die_prop.SetType(self._edb.definition.DieType.FlipChip)
+            ic_die_prop.SetType(self._edb.Definition.DieType.FlipChip)
             if chip_orientation.lower() == "chip_up":
-                ic_die_prop.SetOrientation(self._edb.definition.DieOrientation.ChipUp)
+                ic_die_prop.SetOrientation(self._edb.Definition.DieOrientation.ChipUp)
             else:
-                ic_die_prop.SetOrientation(self._edb.definition.DieOrientation.ChipDown)
+                ic_die_prop.SetOrientation(self._edb.Definition.DieOrientation.ChipDown)
             cmp_property.SetDieProperty(ic_die_prop)
 
         solder_ball_prop = cmp_property.GetSolderBallProperty().Clone()
@@ -2149,13 +2157,13 @@ class Components(object):
             self._logger.info("No parameters passed, component %s  is disabled.", componentname)
             return True
         edb_component = self.get_component_by_name(componentname)._edb_object
-        edb_rlc_component_property = self._edb.cell.hierarchy._hierarchy.RLCComponentProperty()
+        edb_rlc_component_property = self._edb.Cell.Hierarchy.RLCComponentProperty()
         component_pins = self.get_pin_from_component(componentname)
         pin_number = len(component_pins)
         if pin_number == 2:
             from_pin = component_pins[0]
             to_pin = component_pins[1]
-            rlc = self._edb.utility.utility.Rlc()
+            rlc = self._edb.Utility.Rlc()
             rlc.IsParallel = isparallel
             if res_value is not None:
                 rlc.REnabled = True
@@ -2172,8 +2180,8 @@ class Components(object):
                 rlc.C = self._get_edb_value(cap_value)
             else:
                 rlc.CEnabled = False
-            pin_pair = self._edb.utility.utility.PinPair(from_pin.name, to_pin.name)
-            rlc_model = self._edb.cell.hierarchy._hierarchy.PinPairModel()
+            pin_pair = self._edb.Utility.PinPair(from_pin.name, to_pin.name)
+            rlc_model = self._edb.Cell.Hierarchy.PinPairModel()
             rlc_model.SetPinPairRlc(pin_pair, rlc)
             if not edb_rlc_component_property.SetModel(rlc_model) or not edb_component.SetComponentProperty(
                 edb_rlc_component_property
@@ -2310,9 +2318,9 @@ class Components(object):
                         pinlist = self.get_pin_from_component(refdes)
                         if not part_name in self.definitions:
                             footprint_cell = self.definitions[comp.partname]._edb_object.GetFootprintCell()
-                            comp_def = self._edb.definition.ComponentDef.Create(self._db, part_name, footprint_cell)
+                            comp_def = self._edb.Definition.ComponentDef.Create(self._db, part_name, footprint_cell)
                             for pin in pinlist:
-                                self._edb.definition.ComponentDefPin.Create(comp_def, pin._edb_object.GetName())
+                                self._edb.Definition.ComponentDefPin.Create(comp_def, pin._edb_object.GetName())
 
                         p_layer = comp.placement_layer
                         refdes_temp = comp.refdes + "_temp"
@@ -2388,7 +2396,7 @@ class Components(object):
         reference_designator : str
             Reference designator of the component.
         """
-        obj = self._pedb.core.cell.hierarchy.component.FindByName(self._active_layout, reference_designator)
+        obj = self._pedb.core.Cell.Hierarchy.Component.FindByName(self._active_layout, reference_designator)
         return EDBComponent(self._pedb, obj)
 
     def get_pin_from_component(self, component, netName=None, pinName=None, net_name=None, pin_name=None):
@@ -2427,8 +2435,8 @@ class Components(object):
 
         """
         warnings.warn("Use new property :func:`edb.padstacks.get_instances` instead.", DeprecationWarning)
-        if not isinstance(component, self._pedb.core.cell.hierarchy.component):
-            component = self._pedb.core.cell.hierarchy.component.FindByName(self._active_layout, component)
+        if not isinstance(component, self._pedb.core.Cell.Hierarchy.Component):
+            component = self._pedb.core.Cell.Hierarchy.Component.FindByName(self._active_layout, component)
         if pinName:
             warnings.warn("Use argument `pin_name` instead of `pinName`", DeprecationWarning)
         if netName:
@@ -2490,7 +2498,7 @@ class Components(object):
         if isinstance(pin, EDBPadstackInstance):
             pin = pin._edb_padstackinstance
         val = String("")
-        _, name = pin.GetProductProperty(self._edb.core.ProductId.Designer, 11, val)
+        _, name = pin.GetProductProperty(self._edb.ProductId.Designer, 11, val)
         name = str(name).strip("'")
         return name
 
@@ -2552,7 +2560,7 @@ class Components(object):
             transformed_pt_pos = pt_pos
         else:
             transformed_pt_pos = pin.GetComponent().GetTransform().TransformPoint(pt_pos)
-        pin_xy = self._edb.geometry.point_data(
+        pin_xy = self._edb.Geometry.PointData(
             self._get_edb_value(str(transformed_pt_pos.X.ToDouble())),
             self._get_edb_value(str(transformed_pt_pos.Y.ToDouble())),
         )

pyedb/dotnet/database/definition/component_def.py

@@ -88,7 +88,7 @@ class EDBComponentDef(ObjBase):
 
         comp_list = [
             EDBComponent(self._pedb, l)
-            for l in self._pedb.core.cell.hierarchy.component.FindByComponentDef(
+            for l in self._pedb.core.Cell.Hierarchy.Component.FindByComponentDef(
                 self._pedb.active_layout, self.part_name
             )
         ]
@@ -187,16 +187,16 @@ class EDBComponentDef(ObjBase):
 
         from pyedb.dotnet.database.definition.component_model import NPortComponentModel
 
-        edb_object = self._pedb.definition.NPortComponentModel.Create(name)
+        edb_object = self._pedb.core.Definition.NPortComponentModel.Create(name)
         n_port_comp_model = NPortComponentModel(self._pedb, edb_object)
         n_port_comp_model.reference_file = fpath
 
         self._add_component_model(n_port_comp_model)
 
     def create(self, name):
-        cell_type = self._pedb.core.cell.CellType.FootprintCell
+        cell_type = self._pedb.core.Cell.CellType.FootprintCell
         footprint_cell = self._pedb._active_cell.cell.Create(self._pedb.active_db, cell_type, name)
-        edb_object = self._pedb.core.definition.ComponentDef.Create(self._pedb.active_db, name, footprint_cell)
+        edb_object = self._pedb.core.Definition.ComponentDef.Create(self._pedb.active_db, name, footprint_cell)
         return EDBComponentDef(self._pedb, edb_object)
 
     def get_properties(self):

pyedb/dotnet/database/definition/component_model.py

@@ -28,7 +28,7 @@ class ComponentModel(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}
 
 
 class NPortComponentModel(ComponentModel):

pyedb/dotnet/database/definition/package_def.py

@@ -23,7 +23,6 @@ import warnings
 
 from pyedb.dotnet.database.geometry.polygon_data import PolygonData
 from pyedb.dotnet.database.utilities.obj_base import ObjBase
-from pyedb.edb_logger import pyedb_logger
 
 
 class PackageDef(ObjBase):
@@ -62,7 +61,7 @@ class PackageDef(ObjBase):
         edb_object: object
             EDB PackageDef Object
         """
-        edb_object = self._pedb.core.definition.PackageDef.Create(self._pedb.active_db, name)
+        edb_object = self._pedb.core.Definition.PackageDef.Create(self._pedb.active_db, name)
         if component_part_name:
             x_pt1, y_pt1, x_pt2, y_pt2 = list(
                 self._pedb.components.definitions[component_part_name].components.values()
@@ -73,7 +72,7 @@ class PackageDef(ObjBase):
         else:
             bbox = extent_bounding_box
         if bbox is None:
-            pyedb_logger.warning(
+            self._pedb.logger.warning(
                 "Package creation uses bounding box but it cannot be inferred. "
                 "Please set argument 'component_part_name' or 'extent_bounding_box'."
             )