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

pyedb/configuration/cfg_setup.py

@@ -53,14 +53,9 @@ class CfgSetup(CfgBase):
     def _apply_freq_sweep(self, edb_setup):
         for i in self.freq_sweep:
             f_set = []
-            kw = {}
-            for attr in i.get_attributes(exclude="name"):
-                if attr == "frequencies":
-                    for f in i.frequencies:
-                        f_set.append([f.distribution, f.start, f.stop, f.increment])
-                else:
-                    kw[attr] = getattr(i, attr)
-            edb_setup.add_sweep(i.name, frequency_set=f_set, **kw)
+            for f in i.frequencies:
+                f_set.append([f.distribution, f.start, f.stop, f.increment])
+            edb_setup.add_sweep(i.name, frequency_set=f_set, sweep_type=i.type)
 
 
 class CfgSIwaveACSetup(CfgSetup):
@@ -183,62 +178,141 @@ class CfgSetups:
                     continue
 
             stp = {}
-            if s.type == "hfss":
-                for p_name in CfgHFSSSetup(self._pedb).__dict__:
-                    if p_name.startswith("_"):
-                        continue
-                    elif p_name == "type":
-                        stp[p_name] = s.type
-                    elif p_name == "f_adapt":
-                        stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[0].adaptive_frequency
-                    elif p_name == "max_num_passes":
-                        stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[0].max_passes
-                    elif p_name == "max_mag_delta_s":
-                        stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[0].max_delta
-                    elif p_name == "freq_sweep":
-                        f_sweep = []
-                        for _, sw in s.sweeps.items():
-                            sweep_data = {}
-                            for sw_p_name in CfgSweepData().__dict__:
-                                if sw_p_name == "frequencies":
-                                    pass  # Frequencies cannot be read from EDB
-                                else:
-                                    sweep_data[sw_p_name] = getattr(sw, sw_p_name)
-                            f_sweep.append(sweep_data)
-                        stp["freq_sweep"] = f_sweep
-                    elif p_name == "mesh_operations":
-                        mops = []
-                        for _, i in s.mesh_operations.items():
-                            mop = {}
-                            for mop_p_name in CfgLengthMeshOperation().__dict__:
-                                mop[mop_p_name] = getattr(i, mop_p_name)
-                            mops.append(mop)
-                        stp["mesh_operations"] = mops
-                    else:
-                        stp[p_name] = getattr(s, p_name)
-
-            elif s.type == "siwave_ac":
-                for p_name in CfgSIwaveACSetup(self._pedb).__dict__:
-                    if p_name.startswith("_"):
-                        continue
-                    elif p_name == "freq_sweep":
-                        pass  # Bug in EDB API
-                    else:
-                        stp[p_name] = getattr(s, p_name)
-            elif s.type == "siwave_dc":
-                for p_name in CfgSIwaveDCSetup(self._pedb).__dict__:
-                    if p_name.startswith("_"):
-                        continue
-                    elif p_name == "freq_sweep":
-                        pass
-                    elif p_name == "dc_ir_settings":
-                        dc_ir_s = {}
-                        for dcir_p_name in CfgDcIrSettings().__dict__:
-                            dc_ir_s[dcir_p_name] = getattr(s.dc_ir_settings, dcir_p_name)
-                        stp["dc_ir_settings"] = dc_ir_s
-                    elif p_name == "dc_slider_position":
-                        stp[p_name] = getattr(s.dc_settings, p_name)
-                    else:
-                        stp[p_name] = getattr(s, p_name)
+            if self._pedb.grpc:
+                from ansys.edb.core.simulation_setup.mesh_operation import (
+                    LengthMeshOperation as GrpcLengthMeshOperation,
+                )
+
+                s_type = s.type.name.lower()
+                if s_type == "hfss":
+                    for p_name in CfgHFSSSetup(self._pedb).__dict__:
+                        if p_name.startswith("_"):
+                            continue
+                        elif p_name == "type":
+                            stp[p_name] = s.type.name.lower()
+                        elif p_name == "f_adapt":
+                            stp[p_name] = s.settings.general.single_frequency_adaptive_solution.adaptive_frequency
+                        elif p_name == "max_num_passes":
+                            stp[p_name] = s.settings.general.single_frequency_adaptive_solution.max_passes
+                        elif p_name == "max_mag_delta_s":
+                            stp[p_name] = s.settings.general.single_frequency_adaptive_solution.max_delta
+                        elif p_name == "freq_sweep":
+                            f_sweep = []
+                            for sw in s.sweep_data:
+                                sweep_data = {}
+                                for sw_p_name in CfgSweepData().__dict__:
+                                    if sw_p_name == "frequencies":
+                                        pass  # Frequencies cannot be read from EDB
+                                    else:
+                                        sweep_data[sw_p_name] = getattr(sw, sw_p_name)
+                                f_sweep.append(sweep_data)
+                            stp["freq_sweep"] = f_sweep
+                        elif p_name == "mesh_operations":
+                            mops = []
+                            for i in s.mesh_operations:
+                                mop = {}
+                                for mop_p_name in CfgLengthMeshOperation().__dict__:
+                                    if mop_p_name == "type":
+                                        if isinstance(i, GrpcLengthMeshOperation):
+                                            mop[mop_p_name] = "length"
+                                    elif mop_p_name == "nets_layers_list":
+                                        mop[mop_p_name] = i.__dict__["_net_layer_info"]
+                                    elif mop_p_name == "restrict_length":
+                                        mop[mop_p_name] = i.__dict__["_restrict_max_length"]
+                                    else:
+                                        mop[mop_p_name] = i.__dict__[f"_{mop_p_name}"]
+                                mops.append(mop)
+                            stp["mesh_operations"] = mops
+                        else:
+                            stp[p_name] = getattr(s, p_name)
+
+                elif s_type == "siwave_ac":
+                    for p_name in CfgSIwaveACSetup(self._pedb).__dict__:
+                        if p_name.startswith("_"):
+                            continue
+                        elif p_name == "freq_sweep":
+                            pass  # Bug in EDB API
+                        else:
+                            stp[p_name] = getattr(s, p_name)
+                elif s_type == "siwave_dc":
+                    for p_name in CfgSIwaveDCSetup(self._pedb).__dict__:
+                        if p_name.startswith("_"):
+                            continue
+                        elif p_name == "freq_sweep":
+                            pass
+                        elif p_name == "dc_ir_settings":
+                            dc_ir_s = {}
+                            for dcir_p_name in CfgDcIrSettings().__dict__:
+                                dc_ir_s[dcir_p_name] = getattr(s.dc_ir_settings, dcir_p_name)
+                            stp["dc_ir_settings"] = dc_ir_s
+                        elif p_name == "dc_slider_position":
+                            stp[p_name] = getattr(s.dc_settings, p_name)
+                        else:
+                            stp[p_name] = getattr(s, p_name)
+            else:
+                for _, s in self._pedb.setups.items():
+                    if float(self._pedb.edbversion) < 2025.1:
+                        if not s.type == "hfss":
+                            self._pedb.logger.warning("Only HFSS setups are exported in 2024 R2 and earlier version.")
+                            continue
+                    if s.type == "hfss":
+                        for p_name in CfgHFSSSetup(self._pedb).__dict__:
+                            if p_name.startswith("_"):
+                                continue
+                            elif p_name == "type":
+                                stp[p_name] = s.type
+                            elif p_name == "f_adapt":
+                                stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[
+                                    0
+                                ].adaptive_frequency
+                            elif p_name == "max_num_passes":
+                                stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[0].max_passes
+                            elif p_name == "max_mag_delta_s":
+                                stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[0].max_delta
+                            elif p_name == "freq_sweep":
+                                f_sweep = []
+                                for sw in s.sweeps.items():
+                                    sweep_data = {}
+                                    for sw_p_name in CfgSweepData().__dict__:
+                                        if sw_p_name == "frequencies":
+                                            pass  # Frequencies cannot be read from EDB
+                                        else:
+                                            sweep_data[sw_p_name] = getattr(sw[1], sw_p_name)
+                                    f_sweep.append(sweep_data)
+                                stp["freq_sweep"] = f_sweep
+                            elif p_name == "mesh_operations":
+                                mops = []
+                                for _, i in s.mesh_operations.items():
+                                    mop = {}
+                                    for mop_p_name in CfgLengthMeshOperation().__dict__:
+                                        mop[mop_p_name] = getattr(i, mop_p_name)
+                                    mops.append(mop)
+                                stp["mesh_operations"] = mops
+                            else:
+                                stp[p_name] = getattr(s, p_name)
+
+                    elif s.type == "siwave_ac":
+                        for p_name in CfgSIwaveACSetup(self._pedb).__dict__:
+                            if p_name.startswith("_"):
+                                continue
+                            elif p_name == "freq_sweep":
+                                pass  # Bug in EDB API
+                            else:
+                                stp[p_name] = getattr(s, p_name)
+                    elif s.type == "siwave_dc":
+                        for p_name in CfgSIwaveDCSetup(self._pedb).__dict__:
+                            if p_name.startswith("_"):
+                                continue
+                            elif p_name == "freq_sweep":
+                                pass
+                            elif p_name == "dc_ir_settings":
+                                dc_ir_s = {}
+                                for dcir_p_name in CfgDcIrSettings().__dict__:
+                                    dc_ir_s[dcir_p_name] = getattr(s.dc_ir_settings, dcir_p_name)
+                                stp["dc_ir_settings"] = dc_ir_s
+                            elif p_name == "dc_slider_position":
+                                stp[p_name] = getattr(s.dc_settings, p_name)
+                            else:
+                                stp[p_name] = getattr(s, p_name)
             setups.append(stp)
         return setups

pyedb/configuration/configuration.py

@@ -147,19 +147,34 @@ class Configuration:
                 cfg_pdef.api.set_parameters_to_edb()
         else:
             temp_pdef_data = {}
-            for pdef_name, pdef in self._pedb.padstacks.definitions.items():
-                pdef_data = pdef._padstack_def_data
-                for lyr_name in list(pdef_data.GetLayerNames()):
-                    result = pdef_data.GetPadParametersValue(lyr_name, self._pedb._edb.Definition.PadType.RegularPad)
-                    flag, pad_shape, params, offset_x, offset_y, rotation = result
-                    if flag is False:
-                        result = pdef_data.GetPolygonalPadParameters(
+            if self._pedb.grpc:
+                from ansys.edb.core.definition.padstack_def_data import (
+                    PadType as GrpcPadType,
+                )
+
+                for pdef_name, pdef in self._pedb.padstacks.definitions.items():
+                    for layer in pdef.data.layer_names:
+                        result = pdef.data.get_pad_parameters(layer, GrpcPadType.REGULAR_PAD)
+                        if len(result) == 4:
+                            # polygon based
+                            temp_pdef_data[pdef_name] = pdef.data
+                            break
+            else:
+                for pdef_name, pdef in self._pedb.padstacks.definitions.items():
+                    pdef_data = pdef._padstack_def_data
+                    for lyr_name in list(pdef_data.GetLayerNames()):
+                        result = pdef_data.GetPadParametersValue(
                             lyr_name, self._pedb._edb.Definition.PadType.RegularPad
                         )
-                        flag, polygon_data, offset_x, offset_y, rotation = result
-                        if flag:
-                            temp_pdef_data[pdef_name] = pdef_data
-                            break
+                        flag, pad_shape, params, offset_x, offset_y, rotation = result
+                        if flag is False:
+                            result = pdef_data.GetPolygonalPadParameters(
+                                lyr_name, self._pedb._edb.Definition.PadType.RegularPad
+                            )
+                            flag, polygon_data, offset_x, offset_y, rotation = result
+                            if flag:
+                                temp_pdef_data[pdef_name] = pdef_data
+                                break
             self.cfg_data.stackup.apply()
             for pdef_name, pdef_data in temp_pdef_data.items():
                 pdef = self._pedb.padstacks.definitions[pdef_name]

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

@@ -43,6 +43,11 @@ class PadstackInstanceTerminal(Terminal):
             return EDBPadstackInstance(edb_padstack_instance[1], self._pedb).position
         return False
 
+    @property
+    def location(self):
+        """Location of the padstack instance."""
+        return self.position
+
     def create(self, padstack_instance, name=None, layer=None, is_ref=False):
         """Create an edge terminal.
 

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

@@ -78,3 +78,15 @@ class PointTerminal(Terminal):
         layer = self._pedb.stackup.layers[value]._edb_layer
         point_data = self._pedb.point_data(*self.location)
         self._edb_object.SetParameters(point_data, layer)
+
+    @property
+    def location(self):
+        """Location of the terminal."""
+
+        _, point_data, _ = self._edb_object.GetParameters()
+        return [point_data.X.ToDouble(), point_data.Y.ToDouble()]
+
+    @location.setter
+    def location(self, value):
+        layer = self.layer
+        self._edb_object.SetParameters(self._pedb.point_data(*value), layer._edb_object)

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

@@ -107,20 +107,6 @@ class Terminal(Connectable):
         """Get layer of the terminal."""
         return self._pedb.logger.error("Cannot determine terminal layer")
 
-    @property
-    def location(self):
-        """Location of the terminal."""
-        try:
-            _, point_data, _ = self._edb_object.GetParameters()
-            return [point_data.X.ToDouble(), point_data.Y.ToDouble()]
-        except:
-            self._pedb.logger.error("Cannot determine terminal location")
-
-    @location.setter
-    def location(self, value):
-        layer = self.layer
-        self._edb_object.SetParameters(self._pedb.point_data(*value), layer._edb_object)
-
     @property
     def is_circuit_port(self):
         """Whether it is a circuit port."""

pyedb/dotnet/database/dotnet/database.py

@@ -861,6 +861,8 @@ class Database(EdbDotNet):
             db_path,
             read_only,
         )
+        if self._db.IsNull():
+            raise AttributeError(f"Failed to open edb file {db_path}")
         return self._db
 
     def delete(self, db_path):

pyedb/dotnet/database/edb_data/padstacks_data.py

@@ -510,7 +510,7 @@ class EDBPadstack(object):
         list
             List of layers.
         """
-        return self._padstack_def_data.GetLayerNames()
+        return list(self._padstack_def_data.GetLayerNames())
 
     @property
     def via_start_layer(self):
@@ -521,7 +521,7 @@ class EDBPadstack(object):
         str
             Name of the starting layer.
         """
-        return list(self.via_layers)[0]
+        return self.via_layers[0]
 
     @property
     def via_stop_layer(self):
@@ -532,7 +532,7 @@ class EDBPadstack(object):
         str
             Name of the stopping layer.
         """
-        return list(self.via_layers)[-1]
+        return self.via_layers[-1]
 
     @property
     def hole_params(self):
@@ -2141,3 +2141,80 @@ class EDBPadstackInstance(Primitive):
             max_limit=max_limit,
             component_only=component_only,
         )
+
+    def split(self):
+        """Split padstack instance into multiple instances. The new instances only connect adjacent layers."""
+        pdef_name = self.padstack_definition
+        position = self.position
+        net_name = self.net_name
+        name = self.name
+        stackup_layer_range = list(self._pedb.stackup.signal_layers.keys())
+        start_idx = stackup_layer_range.index(self.start_layer)
+        stop_idx = stackup_layer_range.index(self.stop_layer)
+        for idx, (l1, l2) in enumerate(
+            list(zip(stackup_layer_range[start_idx:stop_idx], stackup_layer_range[start_idx + 1 : stop_idx + 1]))
+        ):
+            self._pedb.padstacks.place(position, pdef_name, net_name, f"{name}_{idx}", fromlayer=l1, tolayer=l2)
+        self.delete()
+
+    def convert_hole_to_conical_shape(self, angle=75):
+        """Convert actual padstack instance to microvias 3D Objects with a given aspect ratio.
+
+        Parameters
+        ----------
+        angle : float, optional
+            Angle of laser penetration in degrees. The angle defines the lowest hole diameter with this formula:
+            HoleDiameter -2*tan(laser_angle* Hole depth). Hole depth is the height of the via (dielectric thickness).
+            The default is ``75``.
+            The lowest hole is ``0.75*HoleDepth/HoleDiam``.
+
+        Returns
+        -------
+        """
+        pos = self.position
+        stackup_layers = self._pedb.stackup.stackup_layers
+        signal_layers = self._pedb.stackup.signal_layers
+        layer_idx = list(signal_layers.keys()).index(self.start_layer)
+
+        _layer_idx = list(stackup_layers.keys()).index(self.start_layer)
+        diel_layer_idx = list(stackup_layers.keys())[_layer_idx + 1]
+        diel_thickness = stackup_layers[diel_layer_idx].thickness
+
+        rad_large = self.definition.hole_diameter / 2
+        rad_small = rad_large - diel_thickness * 1 / math.tan(math.radians(angle))
+
+        if layer_idx + 1 < len(signal_layers) / 2:  # upper half of stack
+            rad_u = rad_large
+            rad_l = rad_small
+        else:
+            rad_u = rad_small
+            rad_l = rad_large
+
+        layout = self._pedb.active_layout
+        cloned_circle = self._edb.cell.primitive.circle.create(
+            layout,
+            self.start_layer,
+            self._edb_padstackinstance.GetNet(),
+            self._pedb.edb_value(pos[0]),
+            self._pedb.edb_value(pos[1]),
+            self._pedb.edb_value(rad_u),
+        )
+        cloned_circle2 = self._edb.cell.primitive.circle.create(
+            layout,
+            self.stop_layer,
+            self._edb_padstackinstance.GetNet(),
+            self._pedb.edb_value(pos[0]),
+            self._pedb.edb_value(pos[1]),
+            self._pedb.edb_value(rad_l),
+        )
+        s3d = self._pedb._edb.Cell.Hierarchy.Structure3D.Create(
+            layout, generate_unique_name("via3d_" + self.aedt_name.replace("via_", ""), n=3)
+        )
+        s3d.AddMember(cloned_circle.prim_obj)
+        s3d.AddMember(cloned_circle2.prim_obj)
+        s3d.SetMaterial(self.definition.material)
+        s3d.SetMeshClosureProp(self._pedb._edb.Cell.Hierarchy.Structure3D.TClosure.EndsClosed)
+
+        hole_override_enabled = True
+        hole_override_diam = 0
+        self._edb_object.SetHoleOverride(hole_override_enabled, self._pedb.edb_value(hole_override_diam))

pyedb/dotnet/database/siwave.py

@@ -811,6 +811,7 @@ class EdbSiwave(object):
 
     def add_siwave_syz_analysis(
         self,
+        name=None,
         accuracy_level=1,
         decade_count=10,
         sweeptype=1,
@@ -823,6 +824,8 @@ class EdbSiwave(object):
 
         Parameters
         ----------
+        name : str optional
+            Setup name.
         accuracy_level : int, optional
            Level of accuracy of SI slider. The default is ``1``.
         decade_count : int
@@ -849,7 +852,7 @@ class EdbSiwave(object):
         :class:`pyedb.dotnet.database.edb_data.siwave_simulation_setup_data.SiwaveSYZSimulationSetup`
             Setup object class.
         """
-        setup = self._pedb.create_siwave_syz_setup()
+        setup = self._pedb.create_siwave_syz_setup(name=name)
         sweep = "linear count"
         if sweeptype == 2:
             sweep = "log scale"

pyedb/dotnet/database/utilities/simulation_setup.py

@@ -239,7 +239,7 @@ class SimulationSetup(object):
         """List of frequency sweeps."""
         return {i.name: i for i in self.sim_setup_info.sweep_data_list}
 
-    def add_sweep(self, name, frequency_set: list = None, **kwargs):
+    def add_sweep(self, name, frequency_set: list = None, sweep_type: str = "interpolation", **kwargs):
         """Add frequency sweep.
 
         Parameters
@@ -248,7 +248,8 @@ class SimulationSetup(object):
             Name of the frequency sweep. The default is ``None``.
         frequency_set : list, optional
             List of frequency points. The default is ``None``.
-
+        sweep_type : str, optional
+            Sweep type. The default is ``"interpolation"``. Options are ``"discrete"``,"discrete"``.
         Returns
         -------
 
@@ -265,7 +266,7 @@ class SimulationSetup(object):
         for k, v in kwargs.items():
             if k in dir(sweep_data):
                 setattr(sweep_data, k, v)
-        sweep_data.freq_sweep_type = kwargs.get("sweep_type") if kwargs.get("sweep_type") else "interpolation"
+        sweep_data.type = sweep_type
 
         if frequency_set is None:
             sweep_type = "linear_scale"
@@ -285,6 +286,10 @@ class SimulationSetup(object):
         self._update_setup()
         return sweep_data
 
+    def delete(self):
+        """Delete current simulation setup."""
+        self._pedb.layout.cell.DeleteSimulationSetup(self.name)
+
     def _add_frequency_sweep(self, sweep_data):
         """Add a frequency sweep.
 

pyedb/dotnet/edb.py

@@ -46,6 +46,7 @@ from pyedb.dotnet.database.Variables import decompose_variable_value
 from pyedb.dotnet.database.cell.layout import Layout
 from pyedb.dotnet.database.cell.terminal.terminal import Terminal
 from pyedb.dotnet.database.components import Components
+import pyedb.dotnet.database.dotnet.database
 from pyedb.dotnet.database.dotnet.database import Database
 from pyedb.dotnet.database.edb_data.control_file import (
     ControlFile,
@@ -277,7 +278,7 @@ class Edb(Database):
         if self.active_cell:
             self.logger.info("EDB initialized.")
         else:
-            self.logger.info("Failed to initialize DLLs.")
+            raise AttributeError("Failed to initialize DLLs.")
 
     def __enter__(self):
         return self
@@ -548,10 +549,7 @@ class Edb(Database):
         self.run_as_standalone(self.standalone)
 
         # self.logger.info("EDB Standalone %s", self.standalone)
-        try:
-            self.open(self.edbpath, self.isreadonly)
-        except Exception as e:
-            self.logger.error("Builder is not Initialized.")
+        self.open(self.edbpath, self.isreadonly)
         if not self.active_db:
             self.logger.warning("Error Opening db")
             self._active_cell = None
@@ -761,6 +759,23 @@ class Edb(Database):
         """Active cell."""
         return self._active_cell
 
+    @active_cell.setter
+    def active_cell(self, value):
+        if isinstance(value, str):
+            _cell = [cell for cell in self.circuit_cells if cell.GetName() == value]
+            if _cell:
+                self._active_cell = _cell[0]
+                self._init_objects()
+                self.logger.info(f"Cell {value} set as active")
+            else:
+                raise f"Design {value} not found in database."
+        elif isinstance(value, pyedb.dotnet.database.dotnet.database.CellClassDotNet):
+            self._active_cell = value
+            self._init_objects()
+            self.logger.info(f"Cell {value.GetName()} set as active")
+        else:
+            raise "No valid design."
+
     @property
     def core_components(self):  # pragma: no cover
         """Edb Components methods and properties.

pyedb/grpc/database/components.py

@@ -2274,8 +2274,7 @@ class Components(object):
         pingroup = PinGroup.create(self._active_layout, group_name, pins)
 
         if pingroup.is_null:  # pragma: no cover
-            self._logger.error(f"Failed to create pin group {group_name}.")
-            return False
+            raise RuntimeError(f"Failed to create pin group {group_name}.")
         else:
             for pin in pins:
                 if not pin.net.is_null:

pyedb/grpc/database/hierarchy/component.py

@@ -41,6 +41,7 @@ from ansys.edb.core.hierarchy.pin_pair_model import PinPairModel as GrpcPinPairM
 from ansys.edb.core.hierarchy.sparameter_model import (
     SParameterModel as GrpcSParameterModel,
 )
+from ansys.edb.core.hierarchy.spice_model import SPICEModel as GrpcSPICEModel
 from ansys.edb.core.primitive.primitive import PadstackInstance as GrpcPadstackInstance
 from ansys.edb.core.terminal.terminals import (
     PadstackInstanceTerminal as GrpcPadstackInstanceTerminal,
@@ -49,6 +50,7 @@ from ansys.edb.core.utility.rlc import Rlc as GrpcRlc
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.grpc.database.hierarchy.pin_pair_model import PinPairModel
+from pyedb.grpc.database.hierarchy.s_parameter_model import SparamModel
 from pyedb.grpc.database.hierarchy.spice_model import SpiceModel
 from pyedb.grpc.database.layers.stackup_layer import StackupLayer
 from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
@@ -204,7 +206,13 @@ class Component(GrpcComponentGroup):
         :class:`Model <ansys.edb.core.hierarchy.model.Model>`
 
         """
-        return self.component_property.model
+
+        if isinstance(self.component_property.model, GrpcSPICEModel):
+            return SpiceModel(edb_object=self.component_property.model.msg)
+        elif isinstance(self.component_property.model, GrpcSParameterModel):
+            return SparamModel(edb_object=self.component_property.model.msg)
+        else:
+            return self.component_property.model
 
     @model.setter
     def model(self, value):

pyedb/grpc/database/hierarchy/s_parameter_model.py

@@ -28,6 +28,6 @@ from ansys.edb.core.hierarchy.sparameter_model import (
 class SparamModel(GrpcSParameterModel):  # pragma: no cover
     """Manage :class:`SParameterModel <ansys.edb.core.hierarchy.sparameter_model.SParameterModel>`"""
 
-    def __init__(self, edb_model):
+    def __init__(self, edb_object):
         super().__init__(self.msg)
-        self._edb_model = edb_model
+        self._edb_model = edb_object

pyedb/grpc/database/hierarchy/spice_model.py

@@ -46,3 +46,7 @@ class SpiceModel(GrpcSpiceModel):  # pragma: no cover
 
         """
         return self.model_name
+
+    @property
+    def spice_file_path(self):
+        return self.model_path