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

pyedb/configuration/configuration.py

@@ -27,14 +27,14 @@ import warnings
 
 import toml
 
+from pyedb import Edb
 from pyedb.configuration.cfg_data import CfgData
-from pyedb.dotnet.database.definition.package_def import PackageDef
 
 
 class Configuration:
     """Enables export and import of a JSON configuration file that can be applied to a new or existing design."""
 
-    def __init__(self, pedb):
+    def __init__(self, pedb: Edb):
         self._pedb = pedb
 
         self._components = self._pedb.components.instances
@@ -43,6 +43,11 @@ class Configuration:
         self._spice_model_library = ""
         self.cfg_data = CfgData(self._pedb)
 
+    def __apply_with_logging(self, label: str, func):
+        start = datetime.now()
+        func()
+        self._pedb.logger.info(f"{label} finished. Time lapse {datetime.now() - start}")
+
     def load(self, config_file, append=True, apply_file=False, output_file=None, open_at_the_end=True):
         """Import configuration settings from a configure file.
 
@@ -110,206 +115,293 @@ class Configuration:
         if kwargs.get("fix_padstack_def"):
             warnings.warn("fix_padstack_def is deprecated.", DeprecationWarning)
 
-        if self.cfg_data.variables:
-            self.cfg_data.variables.apply()
+        self.apply_variables()
 
         if self.cfg_data.general:
             self.cfg_data.general.apply()
 
         # Configure boundary settings
-        now = datetime.now()
         if self.cfg_data.boundaries:
-            self.cfg_data.boundaries.apply()
-        self._pedb.logger.info(f"Updating boundaries finished. Time lapse {datetime.now() - now}")
-        now = datetime.now()
+            self.__apply_with_logging("Updating boundaries", self.cfg_data.boundaries.apply)
 
-        # Configure nets
         if self.cfg_data.nets:
-            self.cfg_data.nets.apply()
-        self._pedb.logger.info(f"Updating nets finished. Time lapse {datetime.now() - now}")
-        now = datetime.now()
-
-        # Configure components
-        self.cfg_data.components.apply()
-        self._pedb.logger.info(f"Updating components finished. Time lapse {datetime.now() - now}")
-        now = datetime.now()
-
-        # Configure pin groups
-        self.cfg_data.pin_groups.apply()
-        self._pedb.logger.info(f"Creating pin groups finished. Time lapse {datetime.now() - now}")
-        now = datetime.now()
-
-        # Configure sources
-        self.cfg_data.sources.apply()
-        self._pedb.logger.info(f"Placing sources finished. Time lapse {datetime.now() - now}")
-        now = datetime.now()
-
-        # Configure setup
-        self.cfg_data.setups.apply()
-        self._pedb.logger.info(f"Creating setups finished. Time lapse {datetime.now() - now}")
-        now = datetime.now()
-
-        # Configure stackup
-        self.configuration_stackup()
-        self._pedb.logger.info(f"Updating stackup finished. Time lapse {datetime.now() - now}")
-        now = datetime.now()
-
-        # Configure padstacks
+            self.__apply_with_logging("Updating nets", self.cfg_data.nets.apply)
+
+        self.__apply_with_logging("Updating components", self.cfg_data.components.apply)
+        self.__apply_with_logging("Creating pin groups", self.cfg_data.pin_groups.apply)
+        self.__apply_with_logging("Placing sources", self.cfg_data.sources.apply)
+        self.__apply_with_logging("Creating setups", self.cfg_data.setups.apply)
+
+        self.__apply_with_logging("Applying materials", self.apply_materials)
+        self.__apply_with_logging("Updating stackup", self.apply_stackup)
+
         if self.cfg_data.padstacks:
-            self.cfg_data.padstacks.apply()
-        self._pedb.logger.info(f"Applying padstacks finished. Time lapse {datetime.now() - now}")
-        now = datetime.now()
+            self.__apply_with_logging("Applying padstacks", self.cfg_data.padstacks.apply)
 
-        # Configure S-parameter
-        self.cfg_data.s_parameters.apply()
-        self._pedb.logger.info(f"Applying S-parameters finished. Time lapse {datetime.now() - now}")
-        now = datetime.now()
+        self.__apply_with_logging("Applying S-parameters", self.cfg_data.s_parameters.apply)
 
-        # Configure SPICE models
         for spice_model in self.cfg_data.spice_models:
-            spice_model.apply()
-        self._pedb.logger.info(f"Assigning Spice models finished. Time lapse {datetime.now() - now}")
-        now = datetime.now()
+            self.__apply_with_logging(f"Assigning Spice model {spice_model}", spice_model.apply)
 
-        # Configure package definitions
-        self.cfg_data.package_definitions.apply()
-        self._pedb.logger.info(f"Applying package definitions finished. Time lapse {datetime.now() - now}")
-        now = datetime.now()
+        self.__apply_with_logging("Applying package definitions", self.cfg_data.package_definitions.apply)
+        self.__apply_with_logging("Applying modeler", self.apply_modeler)
+        self.__apply_with_logging("Placing ports", self.cfg_data.ports.apply)
+        self.__apply_with_logging("Placing probes", self.cfg_data.probes.apply)
+        self.__apply_with_logging("Applying operations", self.cfg_data.operations.apply)
 
-        # Modeler
-        self.cfg_data.modeler.apply()
+        return True
+
+    def apply_modeler(self):
+        modeler = self.cfg_data.modeler
+        if modeler.traces:
+            for t in modeler.traces:
+                if t.path:
+                    obj = self._pedb.modeler.create_trace(
+                        path_list=t.path,
+                        layer_name=t.layer,
+                        net_name=t.net_name,
+                        width=t.width,
+                        start_cap_style=t.start_cap_style,
+                        end_cap_style=t.end_cap_style,
+                        corner_style=t.corner_style,
+                    )
+                    obj.aedt_name = t.name
+                else:
+                    obj = self._pedb.modeler.create_trace(
+                        path_list=[t.incremental_path[0]],
+                        layer_name=t.layer,
+                        net_name=t.net_name,
+                        width=t.width,
+                        start_cap_style=t.start_cap_style,
+                        end_cap_style=t.end_cap_style,
+                        corner_style=t.corner_style,
+                    )
+                    obj.aedt_name = t.name
+                    for x, y in t.incremental_path[1:]:
+                        obj.add_point(x, y, True)
+
+        if modeler.padstack_defs:
+            for p in modeler.padstack_defs:
+                pdata = self._pedb._edb.Definition.PadstackDefData.Create()
+                pdef = self._pedb._edb.Definition.PadstackDef.Create(self._pedb.active_db, p.name)
+                pdef.SetData(pdata)
+                pdef = self._pedb.pedb_class.database.edb_data.padstacks_data.EDBPadstack(pdef, self._pedb.padstacks)
+                p.pyedb_obj = pdef
+                p.api.set_parameters_to_edb()
+
+        if modeler.padstack_instances:
+            for p in modeler.padstack_instances:
+                p_inst = self._pedb.padstacks.place(
+                    via_name=p.name,
+                    net_name=p.net_name,
+                    position=p.position,
+                    definition_name=p.definition,
+                    rotation=p.rotation if p.rotation is not None else 0,
+                )
+                p.pyedb_obj = p_inst
+                p.api.set_parameters_to_edb()
+
+        if modeler.planes:
+            for p in modeler.planes:
+                if p.type == "rectangle":
+                    obj = self._pedb.modeler.create_rectangle(
+                        layer_name=p.layer,
+                        net_name=p.net_name,
+                        lower_left_point=p.lower_left_point,
+                        upper_right_point=p.upper_right_point,
+                        corner_radius=p.corner_radius,
+                        rotation=p.rotation,
+                    )
+                    obj.aedt_name = p.name
+                elif p.type == "polygon":
+                    obj = self._pedb.modeler.create_polygon(
+                        main_shape=p.points, layer_name=p.layer, net_name=p.net_name
+                    )
+                    obj.aedt_name = p.name
+                elif p.type == "circle":
+                    obj = self._pedb.modeler.create_circle(
+                        layer_name=p.layer,
+                        net_name=p.net_name,
+                        x=p.position[0],
+                        y=p.position[1],
+                        radius=p.radius,
+                    )
+                    obj.aedt_name = p.name
+                else:
+                    raise RuntimeError(f"Plane type {p.type} not supported")
+
+                for v in p.voids:
+                    for i in self._pedb.layout.primitives:
+                        if i.aedt_name == v:
+                            self._pedb.modeler.add_void(obj, i)
+
+        if modeler.components:
+            for c in modeler.components:
+                obj = self._pedb.components.create(
+                    c.pins,
+                    component_name=c.reference_designator,
+                    placement_layer=c.placement_layer,
+                    component_part_name=c.definition,
+                )
+                c.pyedb_obj = obj
+                c.api.set_parameters_to_edb()
+
+        primitives = self._pedb.layout.find_primitive(**modeler.primitives_to_delete)
+        for i in primitives:
+            i.delete()
+
+    def apply_variables(self):
+        """Set variables into database."""
+        inst = self.cfg_data.variables
+        for i in inst.variables:
+            if i.name.startswith("$"):
+                self._pedb.add_project_variable(i.name, i.value, i.description)
+            else:
+                self._pedb.add_design_variable(i.name, i.value, description=i.description)
+
+    def get_variables(self):
+        """Retrieve variables from database."""
+        self.cfg_data.variables.variables = []
+        for name, obj in self._pedb.design_variables.items():
+            self.cfg_data.variables.add_variable(name, obj.value_string, obj.description)
+        for name, obj in self._pedb.project_variables.items():
+            self.cfg_data.variables.add_variable(name, obj.value_string, obj.description)
+
+    def apply_materials(self):
+        """Apply material settings to the current design"""
+        cfg_stackup = self.cfg_data.stackup
+        if len(cfg_stackup.materials):
+            materials_in_db = {i.lower(): i for i, _ in self._pedb.materials.materials.items()}
+            for mat_in_cfg in cfg_stackup.materials:
+                if mat_in_cfg.name.lower() in materials_in_db:
+                    self._pedb.materials.delete_material(materials_in_db[mat_in_cfg.name.lower()])
+
+                attrs = mat_in_cfg.model_dump(exclude_none=True)
+                mat = self._pedb.materials.add_material(**attrs)
+
+                for i in attrs.get("thermal_modifiers", []):
+                    mat.set_thermal_modifier(**i.to_dict())
+
+    def get_materials(self):
+        """Retrieve materials from the current design.
 
-        # Configure ports
-        self.cfg_data.ports.apply()
-        self._pedb.logger.info(f"Placing ports finished. Time lapse {datetime.now() - now}")
-        now = datetime.now()
+        Parameters
+        ----------
+        append: bool, optional
+            If `True`, append materials to the current material list.
+        """
 
-        # Configure probes
-        self.cfg_data.probes.apply()
-        self._pedb.logger.info(f"Placing probes finished. Time lapse {datetime.now() - now}")
+        self.cfg_data.stackup.materials = []
+        for name, mat in self._pedb.materials.materials.items():
+            self.cfg_data.stackup.add_material(**mat.to_dict())
+
+    def apply_stackup(self):
+        layers = self.cfg_data.stackup.layers
+        input_signal_layers = [i for i in layers if i.type.lower() == "signal"]
+        if len(input_signal_layers) == 0:
+            return
+        else:  # Create materials with default properties used in stackup but not defined
+            materials = [m.name for m in self.cfg_data.stackup.materials]
+            for i in self.cfg_data.stackup.layers:
+                if i.type == "signal":
+                    if i.material not in materials:
+                        self.cfg_data.stackup.add_material(
+                            name=i.material, **self._pedb.materials.default_conductor_property_values
+                        )
+
+                    if i.fill_material not in materials:
+                        self.cfg_data.stackup.add_material(
+                            name=i.material, **self._pedb.materials.default_dielectric_property_values
+                        )
+
+                elif i.type == "dielectric":
+                    if i.material not in materials:
+                        self.cfg_data.stackup.add_material(
+                            name=i.material, **self._pedb.materials.default_dielectric_property_values
+                        )
+
+        if len(self._pedb.stackup.signal_layers) == 0:
+            self.__create_stackup()
+        elif not len(input_signal_layers) == len(self._pedb.stackup.signal_layers):
+            raise Exception(f"Input signal layer count do not match.")
+        else:
+            self.__update_stackup()
 
-        # Configure operations
-        self.cfg_data.operations.apply()
+    def __create_stackup(self):
+        layers_ = list()
+        layers_.extend(self.cfg_data.stackup.layers)
+        for l_attrs in layers_:
+            attrs = l_attrs.model_dump(exclude_none=True)
+            self._pedb.stackup.add_layer_bottom(**attrs)
 
-        return True
+    def __update_stackup(self):
+        """Apply layer settings to the current design"""
 
-    def configuration_stackup(self):
+        # After import stackup, padstacks lose their definitions. They need to be fixed after loading stackup
+        # step 1, archive padstack definitions
         temp_pdef_data = {}
         for pdef_name, pdef in self._pedb.padstacks.definitions.items():
             pdef_edb_object = pdef._padstack_def_data
             temp_pdef_data[pdef_name] = pdef_edb_object
-
+        # step 2, archive padstack instance layer map
         temp_p_inst_layer_map = {}
         for p_inst in self._pedb.layout.padstack_instances:
             temp_p_inst_layer_map[p_inst.id] = p_inst._edb_object.GetLayerMap()
 
-        self.cfg_data.stackup.apply()
-
+        # ----------------------------------------------------------------------
+        # Apply stackup
+        layers = list()
+        layers.extend(self.cfg_data.stackup.layers)
+
+        removal_list = []
+        lc_signal_layers = []
+        for name, obj in self._pedb.stackup.all_layers.items():
+            if obj.type == "dielectric":
+                removal_list.append(name)
+            elif obj.type == "signal":
+                lc_signal_layers.append(obj.id)
+        for l in removal_list:
+            self._pedb.stackup.remove_layer(l)
+
+        # update all signal layers
+        id_name = {i[0]: i[1] for i in self._pedb.stackup.layers_by_id}
+        signal_idx = 0
+        for l in layers:
+            if l.type == "signal":
+                layer_id = lc_signal_layers[signal_idx]
+                layer_name = id_name[layer_id]
+                attrs = l.model_dump(exclude_none=True)
+                self._pedb.stackup.layers[layer_name].update(**attrs)
+                signal_idx = signal_idx + 1
+
+        # add all dielectric layers. Dielectric layers must be added last. Otherwise,
+        # dielectric layer will occupy signal and document layer id.
+        l = layers.pop(0)
+        if l.type == "signal":
+            prev_layer_clone = self._pedb.stackup.layers[l.name]
+        else:
+            attrs = l.model_dump(exclude_none=True)
+            prev_layer_clone = self._pedb.stackup.add_layer_top(**attrs)
+        for idx, l in enumerate(layers):
+            if l.type == "dielectric":
+                attrs = l.model_dump(exclude_none=True)
+                prev_layer_clone = self._pedb.stackup.add_layer_below(base_layer_name=prev_layer_clone.name, **attrs)
+            elif l.type == "signal":
+                prev_layer_clone = self._pedb.stackup.layers[l.name]
+
+        # ----------------------------------------------------------------------
+        # restore padstack definitions
         for pdef_name, pdef_data in temp_pdef_data.items():
             pdef = self._pedb.padstacks.definitions[pdef_name]
             pdef._padstack_def_data = pdef_data
-
+        # restore padstack instance layer map
         for p_inst in self._pedb.layout.padstack_instances:
             p_inst._edb_object.SetLayerMap(temp_p_inst_layer_map[p_inst.id])
 
-    def _load_stackup(self):
-        """Imports stackup information from json."""
-        data = self.data["stackup"]
-        materials = data.get("materials")
-
-        if materials:
-            edb_materials = {i.lower(): i for i, _ in self._pedb.materials.materials.items()}
-            for mat in materials:
-                name = mat["name"].lower()
-                if name in edb_materials:
-                    self._pedb.materials.delete_material(edb_materials[name])
-            for mat in materials:
-                self._pedb.materials.add_material(**mat)
-
-        layers = data.get("layers")
-
-        if layers:
-            input_signal_layers = [i for i in layers if i["type"].lower() == "signal"]
-            if not len(input_signal_layers) == len(self._pedb.stackup.signal_layers):
-                self._pedb.logger.error("Input signal layer count do not match.")
-                return False
-
-            removal_list = []
-            lc_signal_layers = []
-            for name, obj in self._pedb.stackup.all_layers.items():
-                if obj.type == "dielectric":
-                    removal_list.append(name)
-                elif obj.type == "signal":
-                    lc_signal_layers.append(obj.id)
-            for l in removal_list:
-                self._pedb.stackup.remove_layer(l)
-
-            # update all signal layers
-            id_name = {i[0]: i[1] for i in self._pedb.stackup.layers_by_id}
-            signal_idx = 0
-            for l in layers:
-                if l["type"] == "signal":
-                    layer_id = lc_signal_layers[signal_idx]
-                    layer_name = id_name[layer_id]
-                    self._pedb.stackup.layers[layer_name].update(**l)
-                    signal_idx = signal_idx + 1
-
-            # add all dielectric layers. Dielectric layers must be added last. Otherwise,
-            # dielectric layer will occupy signal and document layer id.
-            prev_layer_clone = None
-            l = layers.pop(0)
-            if l["type"] == "signal":
-                prev_layer_clone = self._pedb.stackup.layers[l["name"]]
-            else:
-                prev_layer_clone = self._pedb.stackup.add_layer_top(**l)
-            for idx, l in enumerate(layers):
-                if l["type"] == "dielectric":
-                    prev_layer_clone = self._pedb.stackup.add_layer_below(base_layer_name=prev_layer_clone.name, **l)
-                elif l["type"] == "signal":
-                    prev_layer_clone = self._pedb.stackup.layers[l["name"]]
-
-    def _load_package_def(self):
-        """Imports package definition information from JSON."""
-        comps = self._pedb.components.instances
-        for pkgd in self.data["package_definitions"]:
-            name = pkgd["name"]
-            if name in self._pedb.definitions.package:
-                self._pedb.definitions.package[name].delete()
-            extent_bounding_box = pkgd.get("extent_bounding_box", None)
-            if extent_bounding_box:
-                package_def = PackageDef(self._pedb, name=name, extent_bounding_box=extent_bounding_box)
-            else:
-                package_def = PackageDef(self._pedb, name=name, component_part_name=pkgd["component_definition"])
-            package_def.maximum_power = pkgd["maximum_power"]
-            package_def.therm_cond = pkgd["therm_cond"]
-            package_def.theta_jb = pkgd["theta_jb"]
-            package_def.theta_jc = pkgd["theta_jc"]
-            package_def.height = pkgd["height"]
-
-            heatsink = pkgd.get("heatsink", None)
-            if heatsink:
-                package_def.set_heatsink(
-                    heatsink["fin_base_height"],
-                    heatsink["fin_height"],
-                    heatsink["fin_orientation"],
-                    heatsink["fin_spacing"],
-                    heatsink["fin_thickness"],
-                )
-
-            comp_def_name = pkgd["component_definition"]
-            comp_def = self._pedb.definitions.component[comp_def_name]
-
-            comp_list = dict()
-            if pkgd["apply_to_all"]:
-                comp_list.update(
-                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in pkgd["components"]}
-                )
-            else:
-                comp_list.update(
-                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes in pkgd["components"]}
-                )
-            for _, i in comp_list.items():
-                i.package_def = name
+    def get_stackup(self):
+        self.cfg_data.stackup.layers = []
+        for name, obj in self._pedb.stackup.all_layers.items():
+            self.cfg_data.stackup.add_layer_at_bottom(**obj.properties)
 
     def get_data_from_db(self, **kwargs):
         """Get configuration data from layout.
@@ -323,11 +415,17 @@ class Configuration:
 
         """
         self._pedb.logger.info("Getting data from layout database.")
+        self.get_variables()
+        self.get_materials()
+        self.get_stackup()
+
         data = {}
         if kwargs.get("general", False):
             data["general"] = self.cfg_data.general.get_data_from_db()
+        if kwargs.get("variables", False):
+            data.update(self.cfg_data.variables.model_dump(exclude_none=True))
         if kwargs.get("stackup", False):
-            data["stackup"] = self.cfg_data.stackup.get_data_from_db()
+            data["stackup"] = self.cfg_data.stackup.model_dump(exclude_none=True)
         if kwargs.get("package_definitions", False):
             data["package_definitions"] = self.cfg_data.package_definitions.get_data_from_db()
         if kwargs.get("setups", False):
@@ -389,6 +487,7 @@ class Configuration:
         s_parameters=True,
         padstacks=True,
         general=True,
+        variables=True,
     ):
         """Export the configuration data from layout to a file.
 
@@ -422,6 +521,8 @@ class Configuration:
             Whether to export padstacks.
         general : bool
             Whether to export general information.
+        variables : bool
+            Whether to export variable.
         Returns
         -------
         bool
@@ -440,6 +541,7 @@ class Configuration:
             s_parameters=s_parameters,
             padstacks=padstacks,
             general=general,
+            variables=variables,
         )
 
         file_path = file_path if isinstance(file_path, Path) else Path(file_path)

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.edb_api.cell}
+        self._model_type_mapping = {"PinPairModel": self._pedb.core.cell}
 
     @property
     def model_type(self):

pyedb/dotnet/database/cell/layout.py

@@ -102,7 +102,7 @@ class Layout(ObjBase):
 
     @property
     def _edb(self):
-        return self._pedb.edb_api
+        return self._pedb.core
 
     def expanded_extent(self, nets, extent, expansion_factor, expansion_unitless, use_round_corner, num_increments):
         """Get an expanded polygon for the Nets collection.

pyedb/dotnet/database/cell/layout_obj.py

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

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

@@ -155,7 +155,7 @@ class Path(Primitive):
         width = self.width
         corner_style = self.corner_style
         end_cap_style = self.get_end_cap_style()
-        cloned_path = self._app.edb_api.cell.primitive.path.create(
+        cloned_path = self._app.core.cell.primitive.path.create(
             self._app.active_layout,
             self.layer_name,
             self.net,

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

@@ -264,10 +264,10 @@ class Primitive(Connectable):
         """
         bbox = self.polygon_data._edb_object.GetBBox()
         return [
-            round(bbox.Item1.X.ToDouble(), 6),
-            round(bbox.Item1.Y.ToDouble(), 6),
-            round(bbox.Item2.X.ToDouble(), 6),
-            round(bbox.Item2.Y.ToDouble(), 6),
+            round(bbox.Item1.X.ToDouble(), 9),
+            round(bbox.Item1.Y.ToDouble(), 9),
+            round(bbox.Item2.X.ToDouble(), 9),
+            round(bbox.Item2.Y.ToDouble(), 9),
         ]
 
     def convert_to_polygon(self):
@@ -336,7 +336,7 @@ class Primitive(Connectable):
         list of float
         """
         if isinstance(point, (list, tuple)):
-            point = self._app.edb_api.geometry.point_data(self._app.edb_value(point[0]), self._app.edb_value(point[1]))
+            point = self._app.core.geometry.point_data(self._app.edb_value(point[0]), self._app.edb_value(point[1]))
 
         p0 = self.polygon_data._edb_object.GetClosestPoint(point)
         return [p0.X.ToDouble(), p0.Y.ToDouble()]
@@ -540,7 +540,7 @@ class Primitive(Connectable):
         -------
         list of float
         """
-        if isinstance(point, self._app.edb_api.geometry.geometry.PointData):
+        if isinstance(point, self._app.core.geometry.geometry.PointData):
             point = [point.X.ToDouble(), point.Y.ToDouble()]
         dist = 1e12
         out = None
@@ -821,7 +821,7 @@ class Primitive(Connectable):
             r"$end 'EM properties'\n"
         )
 
-        pid = self._pedb.edb_api.ProductId.Designer
+        pid = self._pedb.core.ProductId.Designer
         _, p = self._edb_object.GetProductProperty(pid, 18, "")
         if p:
             return p
@@ -831,7 +831,7 @@ class Primitive(Connectable):
     @_em_properties.setter
     def _em_properties(self, em_prop):
         """Set EM properties"""
-        pid = self._pedb.edb_api.ProductId.Designer
+        pid = self._pedb.core.ProductId.Designer
         self._edb_object.SetProductProperty(pid, 18, em_prop)
 
     @property

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.edb_api.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.edb_api.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,