pyedb 0.41.0__py3-none-any.whl → 0.42.0__py3-none-any.whl

pyedb/__init__.py

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

pyedb/configuration/cfg_boundaries.py

@@ -53,7 +53,10 @@ class CfgBoundaries(CfgBase):
         if self.pml_operation_frequency:
             self._pedb.hfss.hfss_extent_info.operating_freq = self.pml_operation_frequency
         if self.pml_radiation_factor:
-            self._pedb.hfss.hfss_extent_info.radiation_level = self.pml_radiation_factor
+            if self._pedb.grpc:
+                self._pedb.hfss.hfss_extent_info.pml_radiation_factor = self.pml_radiation_factor
+            else:
+                self._pedb.hfss.hfss_extent_info.radiation_level = self.pml_radiation_factor
         if self.dielectric_extent_type:
             self._pedb.hfss.hfss_extent_info.extent_type = self.dielectric_extent_type.lower()
         # if self.dielectric_base_polygon:
@@ -81,8 +84,14 @@ class CfgBoundaries(CfgBase):
         self.open_region = self._pedb.hfss.hfss_extent_info.use_open_region
         self.open_region_type = self._pedb.hfss.hfss_extent_info.open_region_type
         self.pml_visible = self._pedb.hfss.hfss_extent_info.is_pml_visible
-        self.pml_operation_frequency = self._pedb.hfss.hfss_extent_info.operating_freq.tostring
-        self.pml_radiation_factor = self._pedb.hfss.hfss_extent_info.radiation_level.tostring
+        if self._pedb.grpc:
+            self.pml_operation_frequency = self._pedb.hfss.hfss_extent_info.operating_freq
+        else:
+            self.pml_operation_frequency = self._pedb.hfss.hfss_extent_info.operating_freq.tostring
+        if self._pedb.grpc:
+            self.pml_radiation_factor = self._pedb.hfss.hfss_extent_info.pml_radiation_factor
+        else:
+            self.pml_radiation_factor = self._pedb.hfss.hfss_extent_info.radiation_level.tostring
         self.dielectric_extent_type = self._pedb.hfss.hfss_extent_info.extent_type
         # self.dielectric_base_polygon = self._pedb.hfss.hfss_extent_info.dielectric_base_polygon
         self.horizontal_padding = self._pedb.hfss.hfss_extent_info.dielectric_extent_size

pyedb/configuration/cfg_components.py

@@ -19,14 +19,13 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
-import os
 
 from pyedb.configuration.cfg_common import CfgBase
 from pyedb.dotnet.database.general import pascal_to_snake, snake_to_pascal
 
 
 class CfgComponent(CfgBase):
-    class Common:
+    class Grpc:
         @property
         def pyedb_obj(self):
             return self.parent.pyedb_obj
@@ -35,6 +34,263 @@ class CfgComponent(CfgBase):
             self.parent = parent
             self.pedb = parent.pedb
 
+        def retrieve_model_properties_from_edb(self):
+            from ansys.edb.core.hierarchy.netlist_model import (
+                NetlistModel as GrpcNetlistModel,
+            )
+            from ansys.edb.core.hierarchy.pin_pair_model import (
+                PinPairModel as GrpcPinPairModel,
+            )
+            from ansys.edb.core.hierarchy.sparameter_model import (
+                SParameterModel as GrpcSParameterModel,
+            )
+            from ansys.edb.core.hierarchy.spice_model import (
+                SPICEModel as GrpcSPICEModel,
+            )
+
+            c_p = self.pyedb_obj.component_property
+            model = c_p.model
+            if isinstance(model, GrpcNetlistModel):
+                self.parent.netlist_model["netlist"] = model.netlist
+            elif isinstance(model, GrpcPinPairModel):
+                temp = {}
+                for i in model.pin_pairs():
+                    temp["first_pin"] = i[0]
+                    temp["second_pin"] = i[1]
+                    rlc = model.rlc(i)
+                    temp["is_parallel"] = rlc.is_parallel
+                    temp["resistance"] = rlc.r.value
+                    temp["resistance_enabled"] = rlc.r_enabled
+                    temp["inductance"] = rlc.l.value
+                    temp["inductance_enabled"] = rlc.l_enabled
+                    temp["capacitance"] = rlc.c.value
+                    temp["capacitance_enabled"] = rlc.c_enabled
+                    self.parent.pin_pair_model.append(temp)
+            elif isinstance(model, GrpcSParameterModel):
+                self.parent.s_parameter_model["reference_net"] = model.reference_net
+                self.parent.s_parameter_model["model_name"] = model.component_model
+            elif isinstance(model, GrpcSPICEModel):
+                self.parent.spice_model["model_name"] = model.model_name
+                self.parent.spice_model["model_path"] = model.model_path
+                self.parent.spice_model["sub_circuit"] = model.sub_circuit
+                # check bug #525 status
+                self.parent.spice_model["terminal_pairs"] = [[i, j] for i, j in dict(model.terminals.items())]
+
+        def _set_model_properties_to_edb(self):
+            c_p = self.pyedb_obj.component_property
+            if self.parent.netlist_model:
+                m = self.pedb._edb.Cell.Hierarchy.SParameterModel()
+                m.net_list = self.parent.netlist_model["netlist"]
+                c_p.model = m
+                self.component_property = c_p
+            elif self.parent.pin_pair_model:
+                from ansys.edb.core.hierarchy.pin_pair_model import (
+                    PinPairModel as GrpcPinPairModel,
+                )
+                from ansys.edb.core.utility.rlc import Rlc as GrpcRlc
+                from ansys.edb.core.utility.value import Value as GrpcValue
+
+                m = GrpcPinPairModel.create()
+                for i in self.parent.pin_pair_model:
+                    p = (str(i["first_pin"]), str(i["second_pin"]))
+                    rlc = GrpcRlc(
+                        r_enabled=i["resistance_enabled"],
+                        r=GrpcValue(i["resistance"]),
+                        l_enabled=i["inductance_enabled"],
+                        l=GrpcValue(i["inductance"]),
+                        c_enabled=i["capacitance_enabled"],
+                        c=GrpcValue(i["capacitance"]),
+                        is_parallel=i["is_parallel"],
+                    )
+                    m.set_rlc(pin_pair=p, rlc=rlc)
+                c_p.model = m
+                from ansys.edb.core.hierarchy.pin_pair_model import (
+                    PinPairModel as GrpcPinPairModel,
+                )
+
+                self.pyedb_obj.component_property = c_p
+            elif self.parent.s_parameter_model:
+                from ansys.edb.core.hierarchy.sparameter_model import (
+                    SParameterModel as GrpcSParameterModel,
+                )
+
+                m = GrpcSParameterModel.create(
+                    name=self.parent.s_parameter_model["model_name"],
+                    ref_net=self.parent.s_parameter_model["reference_net"],
+                )
+                c_p.model = m
+                self.component_property = c_p
+            elif self.parent.spice_model:
+                self.pyedb_obj.assign_spice_model(
+                    self.parent.spice_model["model_path"],
+                    self.parent.spice_model["model_name"],
+                    self.parent.spice_model["sub_circuit"],
+                    self.parent.spice_model["terminal_pairs"],
+                )
+
+        def _retrieve_ic_die_properties_from_edb(self):
+            temp = dict()
+            cp = self.pyedb_obj.component_property
+
+            ic_die_prop = cp.die_property
+            die_type = pascal_to_snake(ic_die_prop.die_type.name)
+            temp["type"] = die_type
+            if not die_type == "no_die":
+                temp["orientation"] = pascal_to_snake(ic_die_prop.die_orientation.name)
+                if die_type == "wire_bond":
+                    temp["height"] = ic_die_prop.height.value
+
+            self.parent.ic_die_properties = temp
+
+        def _set_ic_die_properties_to_edb(self):
+            from ansys.edb.core.definition.die_property import (
+                DieOrientation as GrpcDieOrientation,
+            )
+            from ansys.edb.core.definition.die_property import DieType as GrpcDieType
+            from ansys.edb.core.utility.value import Value as GrpcValue
+
+            cp = self.pyedb_obj.component_property
+            ic_die_prop = cp.die_property
+            die_type = self.parent.ic_die_properties.get("type")
+            die_type = snake_to_pascal(die_type)
+            if die_type == "wirebond":
+                ic_die_prop.die_type = GrpcDieType.WIREBOND
+            elif die_type == "flipchip":
+                ic_die_prop.die_type = GrpcDieType.FLIPCHIP
+            elif not die_type == "no_die":
+                orientation = self.parent.ic_die_properties.get("orientation")
+                if orientation == "chip_up":
+                    ic_die_prop.die_orientation = GrpcDieOrientation.CHIP_UP
+                else:
+                    ic_die_prop.die_orientation = GrpcDieOrientation.CHIP_DOWN
+                if die_type == "wire_bond":
+                    height = self.parent.ic_die_properties.get("height")
+                    if height:
+                        ic_die_prop.height = GrpcValue(height)
+            cp.die_property = ic_die_prop
+            self.pyedb_obj.component_property = cp
+
+        def _retrieve_solder_ball_properties_from_edb(self):
+            temp = dict()
+            cp = self.pyedb_obj.component_property
+            solder_ball_prop = None
+            try:
+                solder_ball_prop = cp.solder_ball_property
+                diam, mid_diam = solder_ball_prop.get_diameter()
+                height = solder_ball_prop.height
+                shape = solder_ball_prop.shape.name
+                material = solder_ball_prop.material_name
+                uses_solder_ball = solder_ball_prop.uses_solderball
+
+                temp["uses_solder_ball"] = uses_solder_ball
+                temp["shape"] = pascal_to_snake(shape)
+                temp["diameter"] = diam
+                temp["mid_diameter"] = mid_diam
+                temp["height"] = height
+                temp["material"] = material
+
+                self.parent.solder_ball_properties = temp
+            except:
+                if not solder_ball_prop:
+                    self.pedb.logger.warning(
+                        f"Failed retrieving solder balls property on component {self.pyedb_obj.name}"
+                    )
+
+        def _set_solder_ball_properties_to_edb(self):
+            from ansys.edb.core.definition.solder_ball_property import (
+                SolderballShape as GrpcSolderballShape,
+            )
+            from ansys.edb.core.utility.value import Value as GrpcValue
+
+            cp = self.pyedb_obj.component_property
+            solder_ball_prop = cp.solder_ball_property
+            shape = self.parent.solder_ball_properties.get("shape")
+            if shape == "cylinder":
+                solder_ball_prop.shape = GrpcSolderballShape.SOLDERBALL_CYLINDER
+                diameter = self.parent.solder_ball_properties["diameter"]
+                solder_ball_prop.set_diameter(GrpcValue(diameter), GrpcValue(diameter))
+            elif shape == "spheroid":
+                solder_ball_prop.shape = GrpcSolderballShape.SOLDERBALL_SPHEROID
+                diameter = self.parent.solder_ball_properties["diameter"]
+                mid_diameter = self.parent.solder_ball_properties["mid_diameter"]
+                solder_ball_prop.set_diameter(GrpcValue(diameter), GrpcValue(mid_diameter))
+            else:
+                raise ValueError("Solderball shape must be either cylinder or spheroid")
+
+            solder_ball_prop.height = GrpcValue(self.parent.solder_ball_properties["height"])
+            solder_ball_prop.material_name = self.parent.solder_ball_properties.get("material", "solder")
+            cp.solder_ball_property = solder_ball_prop
+            self.pyedb_obj.component_property = cp
+
+        def _retrieve_port_properties_from_edb(self):
+            temp = dict()
+            cp = self.pyedb_obj.component_property
+            c_type = self.parent.type.lower()
+            if c_type not in ["ic", "io", "other"]:
+                return
+            else:
+                try:
+                    port_prop = cp.port_property
+                    reference_height = port_prop.reference_height.value
+                    reference_size_auto = port_prop.reference_size_auto
+                    reference_size_x, reference_size_y = port_prop.get_reference_size()
+                    temp["reference_height"] = reference_height
+                    temp["reference_size_auto"] = reference_size_auto
+                    temp["reference_size_x"] = reference_size_x.value
+                    temp["reference_size_y"] = reference_size_y.value
+                    self.parent.port_properties = temp
+                except:
+                    self.pedb.logger.warning(f"No port property found on component {self.pyedb_obj.name}")
+
+        def _set_port_properties_to_edb(self):
+            from ansys.edb.core.utility.value import Value as GrpcValue
+
+            cp = self.pyedb_obj.component_property
+            port_prop = cp.port_property
+            height = self.parent.port_properties.get("reference_height")
+            if height:
+                port_prop.reference_height = GrpcValue(height)
+            reference_size_auto = self.parent.port_properties.get("reference_size_auto")
+            if reference_size_auto is not None:
+                port_prop.reference_size_auto = reference_size_auto
+            reference_size_x = self.parent.port_properties.get("reference_size_x", 0)
+            reference_size_y = self.parent.port_properties.get("reference_size_y", 0)
+            port_prop.set_reference_size(GrpcValue(reference_size_x), GrpcValue(reference_size_y))
+            cp.port_property = port_prop
+            self.pyedb_obj.component_property = cp
+
+        def set_parameters_to_edb(self):
+            if self.parent.type:
+                self.pyedb_obj.type = self.parent.type
+            if self.parent.enabled:
+                self.pyedb_obj.enabled = self.parent.enabled
+
+            self._set_model_properties_to_edb()
+            if self.pyedb_obj.type.lower() == "ic":
+                self._set_ic_die_properties_to_edb()
+                self._set_port_properties_to_edb()
+                self._set_solder_ball_properties_to_edb()
+            elif self.pyedb_obj.type.lower() in ["io", "other"]:
+                self._set_solder_ball_properties_to_edb()
+                self._set_port_properties_to_edb()
+
+        def retrieve_parameters_from_edb(self):
+            self.parent.type = self.pyedb_obj.type
+            self.parent.definition = self.pyedb_obj.part_name
+            self.parent.reference_designator = self.pyedb_obj.name
+            self.retrieve_model_properties_from_edb()
+            if self.pyedb_obj.type.lower() == "ic":
+                self._retrieve_ic_die_properties_from_edb()
+                self._retrieve_port_properties_from_edb()
+                self._retrieve_solder_ball_properties_from_edb()
+            elif self.pyedb_obj.type.lower() in ["io", "other"]:
+                self._retrieve_solder_ball_properties_from_edb()
+                self._retrieve_port_properties_from_edb()
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
         def retrieve_model_properties_from_edb(self):
             c_p = self.pyedb_obj.component_property
             model = c_p.GetModel().Clone()
@@ -66,6 +322,39 @@ class CfgComponent(CfgBase):
                     [i, j] for i, j in dict(model.GetTerminalPinPairs()).items()
                 ]
 
+        def _set_ic_die_properties_to_edb(self):
+            cp = self.pyedb_obj.component_property
+            ic_die_prop = cp.GetDieProperty().Clone()
+            die_type = self.parent.ic_die_properties.get("type")
+            ic_die_prop.SetType(getattr(self.pedb._edb.Definition.DieType, snake_to_pascal(die_type)))
+            if not die_type == "no_die":
+                orientation = self.parent.ic_die_properties.get("orientation")
+                if orientation:
+                    ic_die_prop.SetOrientation(
+                        getattr(self.pedb._edb.Definition.DieOrientation, snake_to_pascal(orientation))
+                    )
+                if die_type == "wire_bond":
+                    height = self.parent.ic_die_properties.get("height")
+                    if height:
+                        ic_die_prop.SetHeight(self.pedb.edb_value(height))
+            cp.SetDieProperty(ic_die_prop)
+            self.pyedb_obj.component_property = cp
+
+        def _set_port_properties_to_edb(self):
+            cp = self.pyedb_obj.component_property
+            port_prop = cp.GetPortProperty().Clone()
+            height = self.parent.port_properties.get("reference_height")
+            if height:
+                port_prop.SetReferenceHeight(self.pedb.edb_value(height))
+            reference_size_auto = self.parent.port_properties.get("reference_size_auto")
+            if reference_size_auto is not None:
+                port_prop.SetReferenceSizeAuto(reference_size_auto)
+            reference_size_x = self.parent.port_properties.get("reference_size_x", 0)
+            reference_size_y = self.parent.port_properties.get("reference_size_y", 0)
+            port_prop.SetReferenceSize(self.pedb.edb_value(reference_size_x), self.pedb.edb_value(reference_size_y))
+            cp.SetPortProperty(port_prop)
+            self.pyedb_obj.component_property = cp
+
         def _set_model_properties_to_edb(self):
             c_p = self.pyedb_obj.component_property
             if self.parent.netlist_model:
@@ -87,7 +376,22 @@ class CfgComponent(CfgBase):
                         i["is_parallel"],
                     )
                     m.SetPinPairRlc(p, rlc)
-                c_p.SetModel(m)
+                    c_p.SetModel(m)
+
+                m = self.pedb._edb.Cell.Hierarchy.PinPairModel()
+                for i in self.parent.pin_pair_model:
+                    p = self.pedb._edb.Utility.PinPair(str(i["first_pin"]), str(i["second_pin"]))
+                    rlc = self.pedb._edb.Utility.Rlc(
+                        self.pedb.edb_value(i["resistance"]),
+                        i["resistance_enabled"],
+                        self.pedb.edb_value(i["inductance"]),
+                        i["inductance_enabled"],
+                        self.pedb.edb_value(i["capacitance"]),
+                        i["capacitance_enabled"],
+                        i["is_parallel"],
+                    )
+                    m.SetPinPairRlc(p, rlc)
+                    c_p.SetModel(m)
                 self.pyedb_obj.component_property = c_p
             elif self.parent.s_parameter_model:
                 m = self.pedb._edb.Cell.Hierarchy.SParameterModel()
@@ -103,9 +407,33 @@ class CfgComponent(CfgBase):
                     self.parent.spice_model["terminal_pairs"],
                 )
 
+        def _set_solder_ball_properties_to_edb(self):
+            cp = self.pyedb_obj.component_property
+            solder_ball_prop = cp.GetSolderBallProperty().Clone()
+            shape = self.parent.solder_ball_properties.get("shape")
+            if shape:
+                solder_ball_prop.SetShape(getattr(self.pedb._edb.Definition.SolderballShape, snake_to_pascal(shape)))
+            else:
+                return
+
+            if shape == "cylinder":
+                diameter = self.parent.solder_ball_properties["diameter"]
+                solder_ball_prop.SetDiameter(self.pedb.edb_value(diameter), self.pedb.edb_value(diameter))
+            elif shape == "spheroid":
+                diameter = self.parent.solder_ball_properties["diameter"]
+                mid_diameter = self.parent.solder_ball_properties["mid_diameter"]
+                solder_ball_prop.SetDiameter(self.pedb.edb_value(diameter), self.pedb.edb_value(mid_diameter))
+            else:
+                raise ValueError("Solderball shape must be either cylinder or spheroid")
+            solder_ball_prop.SetHeight(self.pedb.edb_value(self.parent.solder_ball_properties["height"]))
+            solder_ball_prop.SetMaterialName(self.parent.solder_ball_properties.get("material", "solder"))
+            cp.SetSolderBallProperty(solder_ball_prop)
+            self.pyedb_obj.component_property = cp
+
         def _retrieve_ic_die_properties_from_edb(self):
             temp = dict()
             cp = self.pyedb_obj.component_property
+
             ic_die_prop = cp.GetDieProperty().Clone()
             die_type = pascal_to_snake(ic_die_prop.GetType().ToString())
             temp["type"] = die_type
@@ -115,24 +443,6 @@ class CfgComponent(CfgBase):
                     temp["height"] = ic_die_prop.GetHeightValue().ToString()
             self.parent.ic_die_properties = temp
 
-        def _set_ic_die_properties_to_edb(self):
-            cp = self.pyedb_obj.component_property
-            ic_die_prop = cp.GetDieProperty().Clone()
-            die_type = self.parent.ic_die_properties.get("type")
-            ic_die_prop.SetType(getattr(self.pedb._edb.Definition.DieType, snake_to_pascal(die_type)))
-            if not die_type == "no_die":
-                orientation = self.parent.ic_die_properties.get("orientation")
-                if orientation:
-                    ic_die_prop.SetOrientation(
-                        getattr(self.pedb._edb.Definition.DieOrientation, snake_to_pascal(orientation))
-                    )
-                if die_type == "wire_bond":
-                    height = self.parent.ic_die_properties.get("height")
-                    if height:
-                        ic_die_prop.SetHeight(self.pedb.edb_value(height))
-            cp.SetDieProperty(ic_die_prop)
-            self.pyedb_obj.component_property = cp
-
         def _retrieve_solder_ball_properties_from_edb(self):
             temp = dict()
             cp = self.pyedb_obj.component_property
@@ -151,29 +461,6 @@ class CfgComponent(CfgBase):
             temp["material"] = material
             self.parent.solder_ball_properties = temp
 
-        def _set_solder_ball_properties_to_edb(self):
-            cp = self.pyedb_obj.component_property
-            solder_ball_prop = cp.GetSolderBallProperty().Clone()
-            shape = self.parent.solder_ball_properties.get("shape")
-            if shape:
-                solder_ball_prop.SetShape(getattr(self.pedb._edb.Definition.SolderballShape, snake_to_pascal(shape)))
-            else:
-                return
-
-            if shape == "cylinder":
-                diameter = self.parent.solder_ball_properties["diameter"]
-                solder_ball_prop.SetDiameter(self.pedb.edb_value(diameter), self.pedb.edb_value(diameter))
-            elif shape == "spheroid":
-                diameter = self.parent.solder_ball_properties["diameter"]
-                mid_diameter = self.parent.solder_ball_properties["mid_diameter"]
-                solder_ball_prop.SetDiameter(self.pedb.edb_value(diameter), self.pedb.edb_value(mid_diameter))
-            else:
-                raise ValueError("Solderball shape must be either cylinder or spheroid")
-            solder_ball_prop.SetHeight(self.pedb.edb_value(self.parent.solder_ball_properties["height"]))
-            solder_ball_prop.SetMaterialName(self.parent.solder_ball_properties.get("material", "solder"))
-            cp.SetSolderBallProperty(solder_ball_prop)
-            self.pyedb_obj.component_property = cp
-
         def _retrieve_port_properties_from_edb(self):
             temp = dict()
             cp = self.pyedb_obj.component_property
@@ -191,61 +478,10 @@ class CfgComponent(CfgBase):
                 temp["reference_size_y"] = str(reference_size_y)
                 self.parent.port_properties = temp
 
-        def _set_port_properties_to_edb(self):
-            cp = self.pyedb_obj.component_property
-            port_prop = cp.GetPortProperty().Clone()
-            height = self.parent.port_properties.get("reference_height")
-            if height:
-                port_prop.SetReferenceHeight(self.pedb.edb_value(height))
-            reference_size_auto = self.parent.port_properties.get("reference_size_auto")
-            if reference_size_auto is not None:
-                port_prop.SetReferenceSizeAuto(reference_size_auto)
-            reference_size_x = self.parent.port_properties.get("reference_size_x", 0)
-            reference_size_y = self.parent.port_properties.get("reference_size_y", 0)
-            port_prop.SetReferenceSize(self.pedb.edb_value(reference_size_x), self.pedb.edb_value(reference_size_y))
-            cp.SetPortProperty(port_prop)
-            self.pyedb_obj.component_property = cp
-
-        def set_parameters_to_edb(self):
-            if self.parent.type:
-                self.pyedb_obj.type = self.parent.type
-            if self.parent.enabled:
-                self.pyedb_obj.enabled = self.parent.enabled
-
-            self._set_model_properties_to_edb()
-            if self.pyedb_obj.type.lower() == "ic":
-                self._set_ic_die_properties_to_edb()
-                self._set_port_properties_to_edb()
-                self._set_solder_ball_properties_to_edb()
-            elif self.pyedb_obj.type.lower() in ["io", "other"]:
-                self._set_solder_ball_properties_to_edb()
-                self._set_port_properties_to_edb()
-
-        def retrieve_parameters_from_edb(self):
-            self.parent.type = self.pyedb_obj.type
-            self.parent.definition = self.pyedb_obj.part_name
-            self.parent.reference_designator = self.pyedb_obj.name
-            self.retrieve_model_properties_from_edb()
-            if self.pyedb_obj.type.lower() == "ic":
-                self._retrieve_ic_die_properties_from_edb()
-                self._retrieve_port_properties_from_edb()
-                self._retrieve_solder_ball_properties_from_edb()
-            elif self.pyedb_obj.type.lower() in ["io", "other"]:
-                self._retrieve_solder_ball_properties_from_edb()
-                self._retrieve_port_properties_from_edb()
-
-    class Grpc(Common):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
-
     def __init__(self, pedb, pedb_object, **kwargs):
         self.pedb = pedb
         self.pyedb_obj = pedb_object
-        if os.environ["PYEDB_USE_DOTNET"] == "0":
+        if self.pedb.grpc:
             self.api = self.Grpc(self)
         else:
             self.api = self.DotNet(self)
@@ -273,7 +509,7 @@ class CfgComponents:
 
         if components_data:
             for comp in components_data:
-                obj = self.pedb.layout.find_component_by_name(comp["reference_designator"])
+                obj = self.pedb.components.instances[comp["reference_designator"]]
                 self.components.append(CfgComponent(self.pedb, obj, **comp))
 
     def clean(self):

pyedb/configuration/cfg_general.py

@@ -32,10 +32,12 @@ class CfgGeneral:
         self.suppress_pads = data.get("suppress_pads", True)
 
     def apply(self):
-        # TODO check if design_options features exists in grpc
-        # self._pedb.design_options.antipads_always_on = self.anti_pads_always_on
-        # self._pedb.design_options.suppress_pads = self.suppress_pads
-        pass
+        if self._pedb.grpc:
+            self._pedb.active_cell.anti_pads_always_on = self.anti_pads_always_on
+            self._pedb.active_cell.suppress_pads = self.suppress_pads
+        else:
+            self._pedb.design_options.antipads_always_on = self.anti_pads_always_on
+            self._pedb.design_options.suppress_pads = self.suppress_pads
 
     def get_data_from_db(self):
         self.anti_pads_always_on = self._pedb.design_options.antipads_always_on

pyedb/configuration/cfg_pin_groups.py

@@ -38,14 +38,24 @@ class CfgPinGroups:
         self.pin_groups = []
         layout_pin_groups = self._pedb.siwave.pin_groups
         for pg_name, pg_obj in layout_pin_groups.items():
-            pins = list(pg_obj.pins.keys())
-            refdes = list(pg_obj.pins.values())[0].component.name
-            cfg_pg = CfgPinGroup(
-                self._pedb,
-                name=pg_name,
-                reference_designator=refdes,
-                pins=pins,
-            )
+            if self._pedb.grpc:
+                pins = pg_obj.pins
+                refdes = pins[0].component.name
+                cfg_pg = CfgPinGroup(
+                    self._pedb,
+                    name=pg_name,
+                    reference_designator=refdes,
+                    pins=[pin.component_pin for pin in pins],
+                )
+            else:
+                pins = list(pg_obj.pins.keys())
+                refdes = list(pg_obj.pins.values())[0].component.name
+                cfg_pg = CfgPinGroup(
+                    self._pedb,
+                    name=pg_name,
+                    reference_designator=refdes,
+                    pins=pins,
+                )
             self.pin_groups.append(cfg_pg)
         return self.export_properties()