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

pyedb/dotnet/database/geometry/polygon_data.py

@@ -89,8 +89,10 @@ class PolygonData:
     def create_from_points(self, points, closed=True):
         list_of_point_data = []
         for pt in points:
-            list_of_point_data.append(PointData(self._pedb, x=pt[0], y=pt[1]))
-        return self._pedb.edb_api.geometry.api_class.PolygonData(list_of_point_data, closed)
+            list_of_point_data.append(PointData(self._pedb, x=pt[0], y=pt[1])._edb_object)
+        return self._pedb.edb_api.geometry.api_class.PolygonData(
+            convert_py_list_to_net_list(list_of_point_data), closed
+        )
 
     def create_from_bounding_box(self, points):
         bbox = BBox(self._pedb, point_1=points[0], point_2=points[1])

pyedb/dotnet/database/padstack.py

@@ -1153,7 +1153,7 @@ class EdbPadstacks(object):
             Name of the net. The default is ``""``.
         via_name : str, optional
             The default is ``""``.
-        rotation : float, optional
+        rotation : float, str, optional
             Rotation of the padstack in degrees. The default
             is ``0``.
         fromlayer :
@@ -1175,7 +1175,11 @@ class EdbPadstacks(object):
                 padstack = self.definitions[pad].edb_padstack
         position = self._edb.geometry.point_data(position[0], position[1])
         net = self._pedb.nets.find_or_create_net(net_name)
-        rotation = self._get_edb_value(rotation * math.pi / 180)
+        rotation = (
+            self._get_edb_value(rotation * math.pi / 180)
+            if not isinstance(rotation, str)
+            else self._get_edb_value(rotation)
+        )
         sign_layers_values = {i: v for i, v in self._pedb.stackup.signal_layers.items()}
         sign_layers = list(sign_layers_values.keys())
         if not fromlayer:

pyedb/dotnet/database/sim_setup_data/data/sweep_data.py

@@ -19,7 +19,7 @@
 # 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 re
 import warnings
 
 
@@ -524,23 +524,76 @@ class SweepData(object):
 
     def add(self, sweep_type, start, stop, increment):
         sweep_type = sweep_type.replace(" ", "_")
-        start = start.upper().replace("Z", "z") if isinstance(start, str) else str(start)
-        stop = stop.upper().replace("Z", "z") if isinstance(stop, str) else str(stop)
-        increment = increment.upper().replace("Z", "z") if isinstance(increment, str) else int(increment)
-        if sweep_type in ["linear_count", "linear_scale"]:
-            freqs = list(self._edb_object.SetFrequencies(start, stop, increment))
-        elif sweep_type == "log_scale":
-            freqs = list(self._edb_object.SetLogFrequencies(start, stop, increment))
+        start = f"{self._pedb.edb_value(start).ToDouble() / 1e9}GHz"
+        stop = f"{self._pedb.edb_value(stop).ToDouble() / 1e9}GHz"
+
+        if sweep_type == "linear_scale":
+            increment = f"{self._pedb.edb_value(increment).ToDouble() / 1e9}GHz"
+            frequencty_string = f"LIN {start} {stop} {increment}"
         else:
-            raise ValueError("sweep_type must be either 'linear_count', 'linear_scale' or 'log_scale")
-        return self.add_frequencies(freqs)
+            increment = int(increment)
+            if sweep_type == "log_scale":
+                frequencty_string = f"DEC {start} {stop} {increment}"
+            elif sweep_type == "linear_count":
+                frequencty_string = f"LINC {start} {stop} {increment}"
+            else:
+                raise ValueError("sweep_type must be either 'linear_count', 'linear_scale' or 'log_scale")
+        temp = self.frequency_string
+        temp.append(frequencty_string)
+        self.frequency_string = temp
+        return self.frequencies
+
+    @property
+    def frequency_string(self):
+        """A string describing the frequency sweep. Below is an example.
+        ['LIN 0GHz 20GHz 0.05GHz', 'LINC 20GHz 30GHz 10', 'DEC 40GHz 50GHz 10']
+        """
+        pattern = r"(?:LIN[C]?|DEC) [^ ]+ [^ ]+ [^ ]+"
+        grouped = re.findall(pattern, self._edb_object.FrequencyString)
+        return grouped
+
+    @frequency_string.setter
+    def frequency_string(self, value):
+        value = value if isinstance(value, list) else [value]
+        temp = []
+        for i in value:
+            sweep_type, start, stop, increment = i.split(" ")
+            start = start.replace("k", "K").replace("h", "H").replace("Z", "z").replace("g", "G")
+            stop = stop.replace("k", "K").replace("h", "H").replace("Z", "z").replace("g", "G")
+            temp.append(" ".join([sweep_type, start, stop, increment]))
+        value = temp
+        self._edb_object.FrequencyString = " ".join(value)
+
+        frequencies = []
+        for i in value:
+            sweep_type, start, stop, increment = i.split(" ")
+            if sweep_type == "LIN":
+                frequencies.extend(self._edb_object.SetFrequencies(start, stop, increment))
+            else:
+                increment = int(increment)
+                if sweep_type == "DEC":
+                    frequencies.extend(self._edb_object.SetLogFrequencies(start, stop, increment))
+                elif sweep_type == "LINC":
+                    frequencies.extend(self._edb_object.SetFrequencies(start, stop, increment))
+
+        self.clear()
+        self.add_frequencies(frequencies)
 
     def add_frequencies(self, frequencies):
         if not isinstance(frequencies, list):
             frequencies = [frequencies]
+
+        temp = []
+        for i in frequencies:
+            i = self._pedb.edb_value(i).ToDouble()
+            if i not in temp and i not in self.frequencies:
+                temp.append(i)
+        frequencies = temp
+
         for i in frequencies:
             i = self._pedb.edb_value(i).ToString()
             self._edb_object.Frequencies.Add(i)
+        self._update_sweep()
         return list(self._edb_object.Frequencies)
 
     def clear(self):

pyedb/dotnet/database/utilities/simulation_setup.py

@@ -96,8 +96,6 @@ class SimulationSetup(object):
         if self._edb_object:
             self._name = self._edb_object.GetName()
 
-        self._sweep_list = {}
-
     @property
     def sim_setup_info(self):
         return SimSetupInfo(self._pedb, sim_setup=self, edb_object=self._edb_object.GetSimSetupInfo())
@@ -239,7 +237,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, sweep_type: str = "interpolation", **kwargs):
+    def add_sweep(self, name: str = None, frequency_set: list = None, sweep_type: str = "interpolation", **kwargs):
         """Add frequency sweep.
 
         Parameters
@@ -268,22 +266,16 @@ class SimulationSetup(object):
                 setattr(sweep_data, k, v)
         sweep_data.type = sweep_type
 
-        if frequency_set is None:
+        if frequency_set in [None, []]:
             sweep_type = "linear_scale"
             start, stop, increment = "50MHz", "5GHz", "50MHz"
+            frequency_set = [[sweep_type, start, stop, increment]]
+        elif not isinstance(frequency_set[0], list):
+            frequency_set = [frequency_set]
+
+        for fs in frequency_set:
+            sweep_type, start, stop, increment = fs
             sweep_data.add(sweep_type, start, stop, increment)
-        elif len(frequency_set) == 0:
-            pass
-        else:
-            if not isinstance(frequency_set[0], list):
-                frequency_set = [frequency_set]
-            for fs in frequency_set:
-                sweep_data.add(*fs)
-
-        ss_info = self.sim_setup_info
-        ss_info.add_sweep_data(sweep_data)
-        self.set_sim_setup_info(ss_info)
-        self._update_setup()
         return sweep_data
 
     def delete(self):
@@ -298,15 +290,7 @@ class SimulationSetup(object):
         sweep_data: SweepData
         """
         warnings.warn("Use new property :func:`add_sweep_data` instead.", DeprecationWarning)
-        self._sweep_list[sweep_data.name] = sweep_data
-        edb_setup_info = self.sim_setup_info
-
-        if self._setup_type in ["kSIwave", "kHFSS", "kRaptorX", "kHFSSPI"]:
-            for _, v in self._sweep_list.items():
-                edb_setup_info.SweepDataList.Add(v._edb_object)
-
-        self._edb_object = self._set_edb_setup_info(edb_setup_info)
-        self._update_setup()
+        return self.sim_setup_info.add_sweep_data(sweep_data)
 
     def delete_frequency_sweep(self, sweep_data):
         """Delete a frequency sweep.
@@ -316,17 +300,17 @@ class SimulationSetup(object):
             sweep_data : EdbFrequencySweep.
         """
         name = sweep_data.name
-        if name in self._sweep_list:
-            self._sweep_list.pop(name)
+        if name in self.sweeps:
+            self.sweeps.pop(name)
 
         fsweep = []
-        if self.frequency_sweeps:
-            fsweep = [val for key, val in self.frequency_sweeps.items() if not key == name]
+        if self.sweeps:
+            fsweep = [val for key, val in self.sweeps.items() if not key == name]
             self.sim_setup_info._edb_object.SweepDataList.Clear()
             for i in fsweep:
                 self.sim_setup_info._edb_object.SweepDataList.Add(i._edb_object)
             self._update_setup()
-            return True if name in self.frequency_sweeps else False
+            return False if name in self.sweeps else True
 
     def add_frequency_sweep(self, name=None, frequency_sweep=None):
         """Add frequency sweep.

pyedb/dotnet/database/utilities/siwave_simulation_setup.py

@@ -95,6 +95,8 @@ class SiwaveSimulationSetup(SimulationSetup):
             self._edb_object = self._simulation_setup_builder(sim_setup_info._edb_object)
             self._update_setup()
 
+        self._siwave_sweeps_list = []
+
     def create(self, name=None):
         """Create a SIwave SYZ setup.
 
@@ -248,6 +250,34 @@ class SiwaveSimulationSetup(SimulationSetup):
         self._edb_object = self._set_edb_setup_info(edb_setup_info)
         self._update_setup()
 
+    def add_sweep(self, name: str = None, frequency_set: list = None, sweep_type: str = "interpolation", **kwargs):
+        """Add frequency sweep.
+
+        Parameters
+        ----------
+        name : str, optional
+            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
+        -------
+
+        Examples
+        --------
+        >>> setup1 = edbapp.create_siwave_syz_setup("setup1")
+        >>> setup1.add_sweep(name="sw1", frequency_set=["linear count", "1MHz", "100MHz", 10])
+        """
+        sweep_data = SimulationSetup.add_sweep(self, name, frequency_set, sweep_type, **kwargs)
+        self._siwave_sweeps_list.append(sweep_data)
+        return sweep_data
+
+    @property
+    def sweeps(self):
+        """List of frequency sweeps."""
+        return {i.name: i for i in self._siwave_sweeps_list}
+
 
 class SiwaveDCSimulationSetup(SimulationSetup):
     """Manages EDB methods for SIwave DC simulation setup."""

pyedb/dotnet/edb.py

@@ -32,7 +32,6 @@ import re
 import shutil
 import subprocess
 import sys
-import tempfile
 import time
 import traceback
 from typing import Union
@@ -48,10 +47,7 @@ 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,
-    convert_technology_file,
-)
+from pyedb.dotnet.database.edb_data.control_file import convert_technology_file
 from pyedb.dotnet.database.edb_data.design_options import EdbDesignOptions
 from pyedb.dotnet.database.edb_data.edbvalue import EdbValue
 from pyedb.dotnet.database.edb_data.ports import (
@@ -243,7 +239,7 @@ class Edb(Database):
                 else:
                     control_file = convert_technology_file(technology_file, edbversion=edbversion)
             self.logger.info("Translating ODB++ to EDB...")
-            self.import_layout_pcb(edbpath[:-4], working_dir, use_ppe=use_ppe, control_file=control_file)
+            self.import_layout_file(edbpath[:-4], working_dir, use_ppe=use_ppe, control_file=control_file)
             if settings.enable_local_log_file and self.log_name:
                 self._logger.add_file_logger(self.log_name, "Edb")
             self.logger.info("EDB %s was created correctly from %s file.", self.edbpath, edbpath)
@@ -256,7 +252,7 @@ class Edb(Database):
                     control_file = technology_file
                 else:
                     control_file = convert_technology_file(technology_file, edbversion=edbversion)
-            self.import_layout_pcb(edbpath, working_dir, use_ppe=use_ppe, control_file=control_file)
+            self.import_layout_file(edbpath, working_dir, use_ppe=use_ppe, control_file=control_file)
             if settings.enable_local_log_file and self.log_name:
                 self._logger.add_file_logger(self.log_name, "Edb")
             self.logger.info("EDB %s was created correctly from %s file.", self.edbpath, edbpath[-2:])
@@ -610,9 +606,15 @@ class Edb(Database):
         anstranslator_full_path="",
         use_ppe=False,
         control_file=None,
+        map_file=None,
+        tech_file=None,
+        layer_filter=None,
     ):
         """Import a board file and generate an ``edb.def`` file in the working directory.
 
+        .. deprecated:: 0.42.0
+           Use :func:`import_layout_file` method instead.
+
         This function supports all AEDT formats, including DXF, GDS, SML (IPC2581), BRD, MCM, SIP, ZIP and TGZ.
 
         Parameters
@@ -630,6 +632,65 @@ class Edb(Database):
             Path to the XML file. The default is ``None``, in which case an attempt is made to find
             the XML file in the same directory as the board file. To succeed, the XML file and board file
             must have the same name. Only the extension differs.
+        tech_file : str, optional
+            Technology file. The file can be *.ircx, *.vlc.tech, or *.itf
+        map_file : str, optional
+            Layer map .map file.
+        layer_filter:str,optional
+            Layer filter .txt file.
+
+        Returns
+        -------
+        Full path to the AEDB file : str
+        """
+        self.logger.warning("import_layout_pcb method is deprecated, use import_layout_file instead.")
+        return self.import_layout_file(
+            input_file,
+            working_dir,
+            anstranslator_full_path,
+            use_ppe,
+            control_file,
+            map_file,
+            tech_file,
+            layer_filter,
+        )
+
+    def import_layout_file(
+        self,
+        input_file,
+        working_dir="",
+        anstranslator_full_path="",
+        use_ppe=False,
+        control_file=None,
+        map_file=None,
+        tech_file=None,
+        layer_filter=None,
+    ):
+        """Import a board file and generate an ``edb.def`` file in the working directory.
+
+        This function supports all AEDT formats, including DXF, GDS, SML (IPC2581), BRD, MCM, SIP, ZIP and TGZ.
+
+        Parameters
+        ----------
+        input_file : str
+            Full path to the board file.
+        working_dir : str, optional
+            Directory in which to create the ``aedb`` folder. The name given to the AEDB file
+            is the same as the name of the board file.
+        anstranslator_full_path : str, optional
+            Full path to the Ansys translator. The default is ``""``.
+        use_ppe : bool
+            Whether to use the PPE License. The default is ``False``.
+        control_file : str, optional
+            Path to the XML file. The default is ``None``, in which case an attempt is made to find
+            the XML file in the same directory as the board file. To succeed, the XML file and board file
+            must have the same name. Only the extension differs.
+        tech_file : str, optional
+            Technology file. The file can be *.ircx, *.vlc.tech, or *.itf
+        map_file : str, optional
+            Layer map .map file.
+        layer_filter:str,optional
+            Layer filter .txt file.
 
         Returns
         -------
@@ -666,6 +727,12 @@ class Edb(Database):
                 cmd_translator.append("-c={}".format(control_file))
             else:
                 cmd_translator.append('-c="{}"'.format(control_file))
+        if map_file:
+            cmd_translator.append('-g="{}"'.format(map_file))
+        if tech_file:
+            cmd_translator.append('-t="{}"'.format(tech_file))
+        if layer_filter:
+            cmd_translator.append('-f="{}"'.format(layer_filter))
         p = subprocess.Popen(cmd_translator)
         p.wait()
         if not os.path.exists(os.path.join(working_dir, aedb_name)):
@@ -1466,7 +1533,7 @@ class Edb(Database):
             ``True`` when successful, ``False`` when failed.
 
         """
-        if self.import_layout_pcb(
+        if self.import_layout_file(
             inputBrd,
             working_dir=WorkDir,
             anstranslator_full_path=anstranslator_full_path,
@@ -1476,103 +1543,6 @@ class Edb(Database):
         else:
             return False
 
-    def import_gds_file(
-        self,
-        inputGDS,
-        anstranslator_full_path="",
-        use_ppe=False,
-        control_file=None,
-        tech_file=None,
-        map_file=None,
-        layer_filter=None,
-    ):
-        """Import a GDS file and generate an ``edb.def`` file in the working directory.
-
-        ..note::
-            `ANSYSLMD_LICENSE_FILE` is needed to run the translator.
-
-        Parameters
-        ----------
-        inputGDS : str
-            Full path to the GDS file.
-        anstranslator_full_path : str, optional
-            Full path to the Ansys translator.
-        use_ppe : bool, optional
-            Whether to use the PPE License. The default is ``False``.
-        control_file : str, optional
-            Path to the XML file. The default is ``None``, in which case an attempt is made to find
-            the XML file in the same directory as the GDS file. To succeed, the XML file and GDS file must
-            have the same name. Only the extension differs.
-        tech_file : str, optional
-            Technology file. For versions<2024.1 it uses Helic to convert tech file to xml and then imports
-            the gds. Works on Linux only.
-            For versions>=2024.1 it can directly parse through supported foundry tech files.
-        map_file : str, optional
-            Layer map file.
-        layer_filter:str,optional
-            Layer filter file.
-
-        """
-        control_file_temp = os.path.join(tempfile.gettempdir(), os.path.split(inputGDS)[-1][:-3] + "xml")
-        if float(self.edbversion) < 2024.1:
-            if not is_linux and tech_file:
-                self.logger.error("Technology files are supported only in Linux. Use control file instead.")
-                return False
-
-            ControlFile(xml_input=control_file, tecnhology=tech_file, layer_map=map_file).write_xml(control_file_temp)
-            if self.import_layout_pcb(
-                inputGDS,
-                anstranslator_full_path=anstranslator_full_path,
-                use_ppe=use_ppe,
-                control_file=control_file_temp,
-            ):
-                return True
-            else:
-                return False
-        else:
-            if anstranslator_full_path and os.path.exists(anstranslator_full_path):
-                path = anstranslator_full_path
-            else:
-                path = os.path.join(self.base_path, "anstranslator")
-                if is_windows:
-                    path += ".exe"
-
-            temp_map_file = os.path.splitext(inputGDS)[0] + ".map"
-            temp_layermap_file = os.path.splitext(inputGDS)[0] + ".layermap"
-
-            if map_file is None:
-                if os.path.isfile(temp_map_file):
-                    map_file = temp_map_file
-                elif os.path.isfile(temp_layermap_file):
-                    map_file = temp_layermap_file
-                else:
-                    self.logger.error("Unable to define map file.")
-
-            if tech_file is None:
-                if control_file is None:
-                    temp_control_file = os.path.splitext(inputGDS)[0] + ".xml"
-                    if os.path.isfile(temp_control_file):
-                        control_file = temp_control_file
-                    else:
-                        self.logger.error("Unable to define control file.")
-
-                command = [path, inputGDS, f'-g="{map_file}"', f'-c="{control_file}"']
-            else:
-                command = [
-                    path,
-                    inputGDS,
-                    f'-o="{control_file_temp}"' f'-t="{tech_file}"',
-                    f'-g="{map_file}"',
-                    f'-f="{layer_filter}"',
-                ]
-
-            result = subprocess.run(command, capture_output=True, text=True, shell=True)
-            print(result.stdout)
-            print(command)
-            temp_inputGDS = inputGDS.split(".gds")[0]
-            self.edbpath = temp_inputGDS + ".aedb"
-            return self.open_edb()
-
     def _create_extent(
         self,
         net_signals,

pyedb/grpc/database/components.py

@@ -2280,7 +2280,7 @@ class Components(object):
                 if not pin.net.is_null:
                     if pin.net.name:
                         pingroup.net = pin.net
-                        return group_name
+                        return group_name, PinGroup(self._pedb, pingroup)
         return False
 
     def create_pin_group_on_net(self, reference_designator, net_name, group_name=None):

pyedb/grpc/database/definition/component_def.py

@@ -216,3 +216,18 @@ class ComponentDef(GrpcComponentDef):
             n_port_model.reference_file = fpath
             self.add_component_model(n_port_model)
             return n_port_model
+
+    def get_properties(self):
+        data = {}
+        temp = []
+        for i in self.component_pins:
+            temp.append(i.name)
+        data["pin_order"] = temp
+        return data
+
+    def set_properties(self, **kwargs):
+        pin_order = kwargs.get("pin_order")
+        if pin_order:
+            old = {i.name: i for i in self.component_pins}
+            temp = [old[str(i)] for i in pin_order]
+            self.component_pins = temp

pyedb/grpc/database/definition/component_pin.py

@@ -28,5 +28,5 @@ class ComponentPin(GrpcComponentPin):
     """Class managing :class:`ComponentPin <ansys.edb.core.definition.component_pin.ComponentPin>`."""
 
     def __init__(self, pedb, edb_object):
-        super().__init__(edb_object)
+        super().__init__(edb_object.msg)
         self._pedb = pedb

pyedb/grpc/database/definition/materials.py

@@ -587,6 +587,33 @@ class Material(GrpcMaterialDef):
 class Materials(object):
     """Manages EDB methods for material management accessible from `Edb.materials` property."""
 
+    default_conductor_property_values = {
+        "conductivity": 58000000,
+        "dielectric_loss_tangent": 0,
+        "magnetic_loss_tangent": 0,
+        "mass_density": 8933,
+        "permittivity": 1,
+        "permeability": 0.999991,
+        "poisson_ratio": 0.38,
+        "specific_heat": 385,
+        "thermal_conductivity": 400,
+        "youngs_modulus": 120000000000,
+        "thermal_expansion_coefficient": 1.77e-05,
+    }
+    default_dielectric_property_values = {
+        "conductivity": 0,
+        "dielectric_loss_tangent": 0.02,
+        "magnetic_loss_tangent": 0,
+        "mass_density": 1900,
+        "permittivity": 4.4,
+        "permeability": 1,
+        "poisson_ratio": 0.28,
+        "specific_heat": 1150,
+        "thermal_conductivity": 0.294,
+        "youngs_modulus": 11000000000,
+        "thermal_expansion_coefficient": 1.5e-05,
+    }
+
     def __init__(self, edb: Edb):
         self.__edb = edb
         self.__syslib = os.path.join(self.__edb.base_path, "syslib")

pyedb/grpc/database/definition/package_def.py

@@ -26,6 +26,7 @@ from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.edb_logger import pyedb_logger
 from pyedb.grpc.database.utility.heat_sink import HeatSink
+from pyedb.misc.misc import deprecated_property
 
 
 class PackageDef(GrpcPackageDef):
@@ -45,6 +46,11 @@ class PackageDef(GrpcPackageDef):
     """
 
     def __init__(self, pedb, edb_object=None, name=None, component_part_name=None, extent_bounding_box=None):
+        if not edb_object:
+            if name:
+                edb_object = GrpcPackageDef.create(db=pedb.active_db, name=name)
+            else:
+                raise AttributeError("Name must be provided to create and instantiate a PackageDef object.")
         super(GrpcPackageDef, self).__init__(edb_object.msg)
         self._pedb = pedb
         self._edb_object = edb_object
@@ -129,7 +135,6 @@ class PackageDef(GrpcPackageDef):
 
     @therm_cond.setter
     def therm_cond(self, value):
-        self.therm_cond = GrpcValue(value)
         super(PackageDef, self.__class__).thermal_conductivity.__set__(self, GrpcValue(value))
 
     @property
@@ -186,7 +191,20 @@ class PackageDef(GrpcPackageDef):
         :class:`HeatSink <pyedb.grpc.database.utility.heat_sink.HeatSink>`
             HeatSink object.
         """
-        return HeatSink(self._pedb, super().heat_sink)
+        try:
+            return HeatSink(self._pedb, super().heat_sink)
+        except:
+            pass
+
+    @property
+    @deprecated_property
+    def heatsink(self):
+        """Property added for .NET compatibility.
+        . deprecated:: pyedb 0.43.0
+        Use :func:`heat_sink` instead.
+
+        """
+        return self.heat_sink
 
     def set_heatsink(self, fin_base_height, fin_height, fin_orientation, fin_spacing, fin_thickness):
         """Set Heat sink.

pyedb/grpc/database/definition/padstack_def.py

@@ -34,7 +34,7 @@ import ansys.edb.core.geometry.polygon_data
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
 from ansys.edb.core.hierarchy.structure3d import MeshClosure as GrpcMeshClosure
 from ansys.edb.core.hierarchy.structure3d import Structure3D as GrpcStructure3D
-from ansys.edb.core.primitive.primitive import Circle as GrpcCircle
+from ansys.edb.core.primitive.circle import Circle as GrpcCircle
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.generic.general_methods import generate_unique_name
@@ -577,7 +577,10 @@ class PadstackDef(GrpcPadstackDef):
             Possible returned values are ``"through"``, ``"begin_on_upper_pad"``,
             ``"end_on_lower_pad"``, ``"upper_pad_to_lower_pad"``, and ``"undefined"``.
         """
-        return self.data.hole_range.name.lower()
+        try:
+            return self.data.hole_range.name.lower()
+        except:
+            return None
 
     @hole_range.setter
     def hole_range(self, value):

pyedb/grpc/database/hierarchy/component.py

@@ -42,8 +42,10 @@ 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 (
+from ansys.edb.core.primitive.padstack_instance import (
+    PadstackInstance as GrpcPadstackInstance,
+)
+from ansys.edb.core.terminal.padstack_instance_terminal import (
     PadstackInstanceTerminal as GrpcPadstackInstanceTerminal,
 )
 from ansys.edb.core.utility.rlc import Rlc as GrpcRlc