REFACTOR: removing edb-core inheritance (#1710)

* padstackdef refactoring

* refactoring

* refactoring pass #2

* refactoring pass #3

* refactoring pass #4

* refactoring pass #5

* refactoring pass #6

* refactoring pass #7

* refactoring pass #8

* pass #9

* pass #10

* pass #11

* pass #12

* pass #13

* pass #14

* pass #15

* pass #16

* pass #17

* pass #18

* pass #19

* pass #20

* pass #21

* pass #22

* pass #23

* pass #24

* pass #25

* pass #26

* pass #26

* pass #27

* pass #28

* pass #29

* pass #30

* pass #31

* pass #32

* pass #33

* pass #34

* pass #35

* pass #36

* pass #37

* pass #38

* pass #39

* Update src/pyedb/grpc/database/layout/layout.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* chore: adding changelog file 1710.miscellaneous.md [dependabot-skip]

* Update src/pyedb/grpc/database/primitive/path.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* pass #40

* pass #41

* pass #42

* pass #43

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: pyansys-ci-bot <92810346+pyansys-ci-bot@users.noreply.github.com>

Author: 3 people

doc/changelog.d/1710.miscellaneous.md

@@ -0,0 +1 @@
+Removing edb-core inheritance

src/pyedb/extensions/create_cell_array.py

@@ -260,21 +260,21 @@ def is_supported_outline(self, outline) -> bool:
         return outline.type in {"polygon", "rectangle"}
 
     def pitch_from_outline(self, outline):
-        bbox = outline.polygon_data.bbox()
-        return self.edb.value(bbox[1].x - bbox[0].x), self.edb.value(bbox[1].y - bbox[0].y)
+        bbox = outline.polygon_data.bounding_box
+        return self.edb.value(bbox[1][0] - bbox[0][0]), self.edb.value(bbox[1][1] - bbox[0][1])
 
     def is_primitive_to_copy(self, prim):
         return prim.type in {"polygon", "rectangle", "circle"}
 
     def duplicate_primitive(self, prim, dx, dy, i, j):
-        moved_pd = prim.polygon_data.move((dx, dy))
-        voids = [voids.polygon_data.move((dx, dy)) for voids in prim.voids]
+        moved_pd = prim.polygon_data.core.move((dx, dy))
+        voids = [voids.polygon_data.core.move((dx, dy)) for voids in prim.voids]
         return self.edb.modeler.create_polygon(
             moved_pd, layer_name=prim.layer.name, net_name=prim.net.name, voids=voids
         )
 
     def duplicate_path(self, path, dx, dy, i, j):
-        moved_line = path.cast().center_line.move((dx, dy))
+        moved_line = path.core.polygon_data.move((dx, dy))
         self.edb.modeler.create_trace(
             moved_line,
             width=path.width,
@@ -291,7 +291,7 @@ def duplicate_standalone_via(self, via, dx, dy, i, j):
             self.active_layout,
             net=via.net,
             name=f"{via.name}_X{i}_Y{j}",
-            padstack_def=via.definition,
+            padstack_definition=via.definition,
             position_x=pos[0] + dx,
             position_y=pos[1] + dy,
             rotation=0.0,

src/pyedb/grpc/database/components.py

@@ -345,26 +345,25 @@ def refresh_components(self) -> bool:
         self._ics = {}
         self._ios = {}
         self._others = {}
+        type_map = {
+            "resistor": self._res,
+            "capacitor": self._cap,
+            "inductor": self._ind,
+            "ic": self._ics,
+            "io": self._ios,
+            "other": self._others,
+        }
         for i in self._pedb.layout.groups:
             self._cmp[i.name] = i
             try:
-                if i.type == "resistor":
-                    self._res[i.name] = i
-                elif i.type == "capacitor":
-                    self._cap[i.name] = i
-                elif i.type == "inductor":
-                    self._ind[i.name] = i
-                elif i.type == "ic":
-                    self._ics[i.name] = i
-                elif i.type == "io":
-                    self._ios[i.name] = i
-                elif i.type == "other":
-                    self._others[i.name] = i
-                else:
+                target = type_map.get(i.component_type)
+                if target is None:
                     self._logger.warning(
                         f"Unknown component type {i.name} found while refreshing components, will ignore"
                     )
-            except:
+                else:
+                    target[i.name] = i
+            except Exception:
                 self._logger.warning(f"Assigning component {i.name} as default type other.")
                 self._others[i.name] = i
         return True
@@ -1071,13 +1070,13 @@ def create(
             compdef = self._get_component_definition(component_name, pins)
         if not compdef:
             return False
-        new_cmp = GrpcComponentGroup.create(self._active_layout, component_name, compdef.name)
+        new_cmp = GrpcComponentGroup.create(self._active_layout.core, component_name, compdef.name)
         if new_cmp.is_null:
             raise ValueError(f"Failed to create component {component_name}.")
         if hasattr(pins[0], "component") and pins[0].component:
             hosting_component_location = None
             if not pins[0].component.is_null:
-                hosting_component_location = pins[0].component.transform
+                hosting_component_location = pins[0].component.core.transform
         else:
             hosting_component_location = None
         if not len(pins) == len(compdef.component_pins):
@@ -1089,14 +1088,14 @@ def create(
         for padstack_instance, component_pin in zip(pins, compdef.component_pins):
             padstack_instance.is_layout_pin = True
             padstack_instance.name = component_pin.name
-            new_cmp.add_member(padstack_instance)
+            new_cmp.add_member(padstack_instance.core)
         if not placement_layer:
             new_cmp_layer_name = pins[0].padstack_def.data.layer_names[0]
         else:
             new_cmp_layer_name = placement_layer
         if new_cmp_layer_name in self._pedb.stackup.signal_layers:
             new_cmp_placement_layer = self._pedb.stackup.signal_layers[new_cmp_layer_name]
-            new_cmp.placement_layer = new_cmp_placement_layer
+            new_cmp.placement_layer = new_cmp_placement_layer.core
         if r_value:
             new_cmp.component_type = GrpcComponentType.RESISTOR
             is_rlc = True
@@ -1329,12 +1328,12 @@ def delete_single_pin_rlc(self, deactivate_only: bool = False) -> List[str]:
         deleted_comps = []
         for comp, val in self.instances.items():
             if hasattr(val, "pins") and val.pins:
-                if val.num_pins == 1 and val.type in ["Resistor", "Capacitor", "Inductor"]:
+                if val.num_pins == 1 and val.component_type in ["resistor", "capacitor", "inductor"]:
                     if deactivate_only:
                         val.is_enabled = False
-                        val.model_type = "RLC"
+                        val.model_type = "rlc"
                     else:
-                        val.edbcomponent.delete()
+                        val.delete()
                         deleted_comps.append(comp)
         if not deactivate_only:
             self.refresh_components()
@@ -1470,7 +1469,7 @@ def set_solder_ball(
             sball_shape = GrpcSolderballShape.SOLDERBALL_SPHEROID
 
         cmp_property = cmp.component_property
-        if cmp.component_type == GrpcComponentType.IC:
+        if cmp.core.component_type == GrpcComponentType.IC:
             ic_die_prop = cmp_property.die_property
             ic_die_prop.die_type = GrpcDieType.FLIPCHIP
             if not cmp.placement_layer == list(self._pedb.stackup.layers.keys())[0]:
@@ -1696,7 +1695,7 @@ def import_bom(
                         comp.refdes = refdes_temp
 
                         unmount_comp_list.remove(refdes)
-                        comp.ungroup(True)
+                        comp.core.ungroup(True)
                         self.create(pinlist, refdes, p_layer, part_name)
                         self.refresh_components()
                         comp = self.instances[refdes]
@@ -1858,7 +1857,7 @@ def get_pin_position(self, pin: Any) -> List[float]:
         if pin.component.is_null:
             transformed_pt_pos = pt_pos
         else:
-            transformed_pt_pos = pin.component.transform.transform_point(pt_pos)
+            transformed_pt_pos = pin.component.core.transform.transform_point(pt_pos)
         return [Value(transformed_pt_pos[0]), Value(transformed_pt_pos[1])]
 
     def get_pins_name_from_net(self, net_name: str, pin_list: Optional[List[Any]] = None) -> List[str]:

src/pyedb/grpc/database/definition/component_def.py

@@ -102,7 +102,11 @@ def components(self) -> dict[str, Component]:
         -------
         dict[str, :class:`Component <pyedb.grpc.database.hierarchy.component.Component>`]
         """
-        comp_list = [Component(self._pedb, l) for l in Component.find_by_def(self._pedb.active_layout, self.part_name)]
+        from ansys.edb.core.hierarchy.component_group import ComponentGroup as GrpcComponent
+
+        comp_list = [
+            Component(self._pedb, l) for l in GrpcComponent.find_by_def(self._pedb.active_layout.core, self.part_name)
+        ]
         return {comp.refdes: comp for comp in comp_list}
 
     @property