pyedb 0.53.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

pyedb/generic/settings.py

@@ -21,12 +21,24 @@
 # SOFTWARE.
 
 import os
+import re
+import sys
 import time
+import warnings
 
 
 class Settings(object):
     """Manages all PyEDB environment variables and global settings."""
 
+    INSTALLED_VERSIONS = None
+    INSTALLED_STUDENT_VERSIONS = None
+    INSTALLED_CLIENT_VERSIONS = None
+    LATEST_VERSION = None
+    LATEST_STUDENT_VERSION = None
+
+    specified_version = None
+    is_student_version = False
+
     def __init__(self):
         self.remote_rpc_session = False
         self._enable_screen_logs = True
@@ -58,26 +70,12 @@ class Settings(object):
         self._global_log_file_size = 10
         self._lsf_queue = None
         self._edb_environment_variables = {}
-        self._use_pyaedt_log = False
-        self._logger = None
-
-    @property
-    def logger(self):
-        """Active logger."""
-        return self._logger
-
-    @logger.setter
-    def logger(self, val):
-        self._logger = val
+        self.logger = None
+        self.log_file = None
+        self._aedt_version = None
 
-    @property
-    def use_pyaedt_log(self):
-        """Flag that disable Edb log when PyAEDT is used."""
-        return self._use_pyaedt_log
-
-    @use_pyaedt_log.setter
-    def use_pyaedt_log(self, value):
-        self._use_pyaedt_log = value
+        self.__get_version_information()
+        self.__init_logger()
 
     @property
     def edb_environment_variables(self):
@@ -261,5 +259,63 @@ class Settings(object):
     def retry_n_times_time_interval(self, value):
         self._retry_n_times_time_interval = float(value)
 
+    def __get_version_information(self):
+        """Get the installed AEDT versions.
+
+        This method returns a dictionary, with the version as the key and the installation path
+        as the value."""
+        version_pattern = re.compile(r"^(ANSYSEM_ROOT|ANSYSEM_PY_CLIENT_ROOT|ANSYSEMSV_ROOT)\d{3}$")
+        env_list = sorted([x for x in os.environ if version_pattern.match(x)], reverse=True)
+        if not env_list:  # pragma: no cover
+            warnings.warn("No installed versions of AEDT are found in the system environment variables.")
+            return
+
+        aedt_system_env_variables = {i: os.environ[i] for i in env_list}
+
+        standard_versions = {}
+        client_versions = {}
+        student_versions = {}
+        # version_list is ordered: first normal versions, then client versions, finally student versions
+        for var_name, aedt_path in aedt_system_env_variables.items():
+            version_id = var_name[-3:]
+            version, release = version_id[0:2], version_id[2]
+            version_name = f"20{version}.{release}"
+            if "ANSYSEM_ROOT" in var_name:
+                standard_versions[version_name] = aedt_path
+            elif "ANSYSEM_PY_CLIENT_ROOT" in var_name:
+                client_versions[version_name] = aedt_path
+            else:
+                student_versions[version_name] = aedt_path
+        self.INSTALLED_VERSIONS = standard_versions
+        self.INSTALLED_STUDENT_VERSIONS = student_versions
+        self.INSTALLED_CLIENT_VERSIONS = client_versions
+
+        if len(self.INSTALLED_VERSIONS):
+            self.LATEST_VERSION = max(standard_versions.keys(), key=lambda x: tuple(map(int, x.split("."))))
+        if len(self.INSTALLED_STUDENT_VERSIONS):
+            self.LATEST_STUDENT_VERSION = max(student_versions.keys(), key=lambda x: tuple(map(int, x.split("."))))
+
+    @property
+    def aedt_installation_path(self):
+        if self.edb_dll_path:
+            return self.edb_dll_path
+        elif self.is_student_version:
+            return self.INSTALLED_STUDENT_VERSIONS[self.specified_version]
+        elif self.specified_version in self.INSTALLED_VERSIONS.keys():
+            return self.INSTALLED_VERSIONS[self.specified_version]
+        elif os.name == "posix":
+            main = sys.modules["__main__"]
+            if "oDesktop" in dir(main):
+                return main.oDesktop.GetExeDir()
+            else:
+                raise RuntimeError(f"Version {self.specified_version} is not installed on the system. ")
+        else:
+            raise RuntimeError(f"Version {self.specified_version} is not installed on the system. ")
+
+    def __init_logger(self):
+        from pyedb.edb_logger import EdbLogger
+
+        self.logger = EdbLogger(to_stdout=self.enable_screen_logs, settings=self)
+
 
 settings = Settings()

pyedb/grpc/database/components.py

@@ -39,7 +39,6 @@ from ansys.edb.core.definition.solder_ball_property import (
 from ansys.edb.core.hierarchy.component_group import ComponentType as GrpcComponentType
 from ansys.edb.core.hierarchy.spice_model import SPICEModel as GrpcSPICEModel
 from ansys.edb.core.utility.rlc import Rlc as GrpcRlc
-from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.component_libraries.ansys_components import (
     ComponentLib,
@@ -57,6 +56,8 @@ from pyedb.grpc.database.hierarchy.pin_pair_model import PinPairModel
 from pyedb.grpc.database.hierarchy.pingroup import PinGroup
 from pyedb.grpc.database.padstacks import Padstacks
 from pyedb.grpc.database.utility.sources import SourceType
+from pyedb.grpc.database.utility.value import Value
+from pyedb.misc.decorators import deprecate_argument_name
 from pyedb.modeler.geometry_operators import GeometryOperators
 
 
@@ -500,6 +501,7 @@ class Components(object):
         """
         return self.instances[name]
 
+    @deprecate_argument_name({"pinName": "pin_name"})
     def get_pin_from_component(
         self,
         component: Union[str, Component],
@@ -1098,17 +1100,17 @@ class Components(object):
                 rlc.r_enabled = False
             else:
                 rlc.r_enabled = True
-                rlc.r = GrpcValue(r_value)
+                rlc.r = Value(r_value)
             if l_value is None:
                 rlc.l_enabled = False
             else:
                 rlc.l_enabled = True
-                rlc.l = GrpcValue(l_value)
+                rlc.l = Value(l_value)
             if c_value is None:
                 rlc.c_enabled = False
             else:
                 rlc.c_enabled = True
-                rlc.C = GrpcValue(c_value)
+                rlc.C = Value(c_value)
             if rlc.r_enabled and not rlc.c_enabled and not rlc.l_enabled:
                 new_cmp.component_type = GrpcComponentType.RESISTOR
             elif rlc.c_enabled and not rlc.r_enabled and not rlc.l_enabled:
@@ -1434,12 +1436,12 @@ class Components(object):
             pin1 = list(cmp.pins.values())[0]
             pin_layers = pin1.padstack_def.data.layer_names
             pad_params = self._pedb.padstacks.get_pad_parameters(pin=pin1, layername=pin_layers[0], pad_type=0)
-            _sb_diam = min([abs(GrpcValue(val).value) for val in pad_params[1]])
+            _sb_diam = min([abs(Value(val)) for val in pad_params[1]])
             sball_diam = 0.8 * _sb_diam
         if sball_height:
-            sball_height = round(GrpcValue(sball_height).value, 9)
+            sball_height = Value(sball_height)
         else:
-            sball_height = round(GrpcValue(sball_diam).value, 9) / 2
+            sball_height = Value(sball_diam)
 
         if not sball_mid_diam:
             sball_mid_diam = sball_diam
@@ -1460,17 +1462,17 @@ class Components(object):
             cmp_property.die_property = ic_die_prop
 
         solder_ball_prop = cmp_property.solder_ball_property
-        solder_ball_prop.set_diameter(GrpcValue(sball_diam), GrpcValue(sball_mid_diam))
-        solder_ball_prop.height = GrpcValue(sball_height)
+        solder_ball_prop.set_diameter(Value(sball_diam), Value(sball_mid_diam))
+        solder_ball_prop.height = Value(sball_height)
 
         solder_ball_prop.shape = sball_shape
         cmp_property.solder_ball_property = solder_ball_prop
 
         port_prop = cmp_property.port_property
-        port_prop.reference_height = GrpcValue(reference_height)
+        port_prop.reference_height = Value(reference_height)
         port_prop.reference_size_auto = auto_reference_size
         if not auto_reference_size:
-            port_prop.set_reference_size(GrpcValue(reference_size_x), GrpcValue(reference_size_y))
+            port_prop.set_reference_size(Value(reference_size_x), Value(reference_size_y))
         cmp_property.port_property = port_prop
         cmp.component_property = cmp_property
         return True
@@ -1520,17 +1522,17 @@ class Components(object):
             rlc.is_parallel = isparallel
             if res_value is not None:
                 rlc.r_enabled = True
-                rlc.r = GrpcValue(res_value)
+                rlc.r = Value(res_value)
             else:
                 rlc.r_enabled = False
             if ind_value is not None:
                 rlc.l_enabled = True
-                rlc.l = GrpcValue(ind_value)
+                rlc.l = Value(ind_value)
             else:
                 rlc.l_enabled = False
             if cap_value is not None:
                 rlc.c_enabled = True
-                rlc.c = GrpcValue(cap_value)
+                rlc.c = Value(cap_value)
             else:
                 rlc.CEnabled = False
             pin_pair = (from_pin.name, to_pin.name)
@@ -1838,7 +1840,7 @@ class Components(object):
             transformed_pt_pos = pt_pos
         else:
             transformed_pt_pos = pin.component.transform.transform_point(pt_pos)
-        return [transformed_pt_pos[0].value, transformed_pt_pos[1].value]
+        return [Value(transformed_pt_pos[0]), Value(transformed_pt_pos[1])]
 
     def get_pins_name_from_net(self, net_name: str, pin_list: Optional[List[Any]] = None) -> List[str]:
         """Get pin names from net.
@@ -2021,8 +2023,8 @@ class Components(object):
                 w = min(pars[0], w)
             elif pad.polygon_data:  # pragma: no cover
                 bbox = pad.polygon_data.bbox()
-                lower = [bbox[0].x.value, bbox[0].y.value]
-                upper = [bbox[1].x.value, bbox[1].y.value]
+                lower = [Value(bbox[0].x), Value(bbox[0].y)]
+                upper = [Value(bbox[1].x), Value(bbox[1].y)]
                 pars = [abs(lower[0] - upper[0]), abs(lower[1] - upper[1])]
                 delta_pins.append(max(pars) + min(pars) / 2)
                 w = min(min(pars), w)
@@ -2228,6 +2230,42 @@ class Components(object):
             component=component.refdes, circuit_ports=create_circuit_port, pec_boundary=pec_boundary
         )
 
+    def add_port_on_rlc_component(
+        self, component: Optional[Union[str, Component]] = None, circuit_ports: bool = True, pec_boundary: bool = False
+    ) -> bool:
+        """Deactivate RLC component and replace it with a circuit port.
+        The circuit port supports only two-pin components.
+
+        Parameters
+        ----------
+        component : str
+            Reference designator of the RLC component.
+
+        circuit_ports : bool
+            ``True`` will replace RLC component by circuit ports, ``False`` gap ports compatible with HFSS 3D modeler
+            export.
+
+        pec_boundary : bool, optional
+            Whether to define the PEC boundary, The default is ``False``. If set to ``True``,
+            a perfect short is created between the pin and impedance is ignored. This
+            parameter is only supported on a port created between two pins, such as
+            when there is no pin group.
+
+        Returns
+        -------
+        bool
+            ``True`` when successful, ``False`` when failed.
+
+        Examples
+        --------
+        >>> from pyedb import Edb
+        >>> edb = Edb()
+        >>> edb.source_excitation.add_port_on_rlc_component("R1")
+        """
+        return self._pedb.source_excitation.add_port_on_rlc_component(
+            component=component, circuit_ports=circuit_ports, pec_boundary=pec_boundary
+        )
+
     def replace_rlc_by_gap_boundaries(self, component: Optional[Union[str, Component]] = None) -> bool:
         """Replace RLC component by RLC gap boundaries. These boundary types are compatible with 3D modeler export.
         Only 2 pins RLC components are supported in this command.

pyedb/grpc/database/control_file.py

@@ -27,8 +27,8 @@ import subprocess
 import sys
 from typing import Any, Dict, List, Optional, Union
 
-from pyedb.edb_logger import pyedb_logger
 from pyedb.generic.general_methods import ET, env_path, env_value, is_linux
+from pyedb.generic.settings import settings
 from pyedb.misc.aedtlib_personalib_install import write_pretty_xml
 from pyedb.misc.misc import list_installed_ansysem
 
@@ -194,7 +194,7 @@ def convert_technology_file(tech_file, edbversion=None, control_file=None):
             base_path = env_path(edbversion)
             sys.path.append(base_path)
         else:
-            pyedb_logger.error("No EDB installation found. Check environment variables")
+            settings.logger.error("No EDB installation found. Check environment variables")
             return False
         os.environ["HELIC_ROOT"] = os.path.join(base_path, "helic")
         if os.getenv("ANSYSLMD_LICENCE_FILE", None) is None:
@@ -207,7 +207,7 @@ def convert_technology_file(tech_file, edbversion=None, control_file=None):
                             os.environ["ANSYSLMD_LICENSE_FILE"] = line.split("=")[1]
                             break
             else:
-                pyedb_logger.error("ANSYSLMD_LICENSE_FILE is not defined.")
+                settings.logger.error("ANSYSLMD_LICENSE_FILE is not defined.")
         vlc_file_name = os.path.splitext(tech_file)[0]
         if not control_file:
             control_file = vlc_file_name + ".xml"
@@ -241,9 +241,9 @@ def convert_technology_file(tech_file, edbversion=None, control_file=None):
             p = subprocess.Popen(command, env=my_env)
             p.wait()
         if os.path.exists(control_file):
-            pyedb_logger.info("XML file created.")
+            settings.logger.info("XML file created.")
             return control_file
-    pyedb_logger.error("Technology files are supported only in Linux. Use control file instead.")
+    settings.logger.error("Technology files are supported only in Linux. Use control file instead.")
     return False
 
 

pyedb/grpc/database/definition/materials.py

@@ -40,11 +40,11 @@ from ansys.edb.core.definition.material_def import MaterialDef as GrpcMaterialDe
 from ansys.edb.core.definition.multipole_debye_model import (
     MultipoleDebyeModel as GrpcMultipoleDebyeModel,
 )
-from ansys.edb.core.utility.value import Value as GrpcValue
 from pydantic import BaseModel, confloat
 
 from pyedb import Edb
 from pyedb.exceptions import MaterialModelException
+from pyedb.grpc.database.utility.value import Value
 
 logger = logging.getLogger(__name__)
 
@@ -181,8 +181,7 @@ class Material(GrpcMaterialDef):
          Conductivity value.
         """
         try:
-            value = self.get_property(GrpcMaterialProperty.CONDUCTIVITY).value
-            return value
+            return Value(self.get_property(GrpcMaterialProperty.CONDUCTIVITY))
         except:
             return 0.0
 
@@ -195,7 +194,7 @@ class Material(GrpcMaterialDef):
                 f"Changing conductivity is only allowed when no dielectric model is assigned."
             )
         else:
-            self.set_property(GrpcMaterialProperty.CONDUCTIVITY, GrpcValue(value))
+            self.set_property(GrpcMaterialProperty.CONDUCTIVITY, Value(value))
 
     @property
     def dc_conductivity(self):
@@ -310,15 +309,14 @@ class Material(GrpcMaterialDef):
 
         """
         try:
-            value = self.get_property(GrpcMaterialProperty.PERMITTIVITY).value
-            return value
+            return Value(self.get_property(GrpcMaterialProperty.PERMITTIVITY))
         except:
             return 0.0
 
     @permittivity.setter
     def permittivity(self, value):
         """Set material permittivity."""
-        self.set_property(GrpcMaterialProperty.PERMITTIVITY, GrpcValue(value))
+        self.set_property(GrpcMaterialProperty.PERMITTIVITY, Value(value))
 
     @property
     def permeability(self) -> float:
@@ -331,15 +329,14 @@ class Material(GrpcMaterialDef):
 
         """
         try:
-            value = self.get_property(GrpcMaterialProperty.PERMEABILITY).value
-            return value
+            return Value(self.get_property(GrpcMaterialProperty.PERMEABILITY))
         except:
             return 0.0
 
     @permeability.setter
     def permeability(self, value):
         """Set material permeability."""
-        self.set_property(GrpcMaterialProperty.PERMEABILITY, GrpcValue(value))
+        self.set_property(GrpcMaterialProperty.PERMEABILITY, Value(value))
 
     @property
     def loss_tangent(self):
@@ -369,7 +366,7 @@ class Material(GrpcMaterialDef):
 
         """
         try:
-            return self.get_property(GrpcMaterialProperty.DIELECTRIC_LOSS_TANGENT).value
+            return Value(self.get_property(GrpcMaterialProperty.DIELECTRIC_LOSS_TANGENT))
         except:
             return 0.0
 
@@ -381,12 +378,12 @@ class Material(GrpcMaterialDef):
             "Use property dielectric_loss_tangent instead.",
             DeprecationWarning,
         )
-        self.dielectric_loss_tangent(value)
+        self.dielectric_loss_tangent = value
 
     @dielectric_loss_tangent.setter
     def dielectric_loss_tangent(self, value):
         """Set material loss tangent."""
-        self.set_property(GrpcMaterialProperty.DIELECTRIC_LOSS_TANGENT, GrpcValue(value))
+        self.set_property(GrpcMaterialProperty.DIELECTRIC_LOSS_TANGENT, Value(value))
 
     @property
     def magnetic_loss_tangent(self) -> float:
@@ -398,15 +395,14 @@ class Material(GrpcMaterialDef):
             Magnetic loss tangent value.
         """
         try:
-            value = self.get_property(GrpcMaterialProperty.MAGNETIC_LOSS_TANGENT).value
-            return value
+            return Value(self.get_property(GrpcMaterialProperty.MAGNETIC_LOSS_TANGENT))
         except:
             return 0.0
 
     @magnetic_loss_tangent.setter
     def magnetic_loss_tangent(self, value):
         """Set material magnetic loss tangent."""
-        self.set_property(GrpcMaterialProperty.MAGNETIC_LOSS_TANGENT, GrpcValue(value))
+        self.set_property(GrpcMaterialProperty.MAGNETIC_LOSS_TANGENT, Value(value))
 
     @property
     def thermal_conductivity(self) -> float:
@@ -419,15 +415,14 @@ class Material(GrpcMaterialDef):
 
         """
         try:
-            value = self.get_property(GrpcMaterialProperty.THERMAL_CONDUCTIVITY).value
-            return value
+            return Value(self.get_property(GrpcMaterialProperty.THERMAL_CONDUCTIVITY))
         except:
             return 0.0
 
     @thermal_conductivity.setter
     def thermal_conductivity(self, value):
         """Set material thermal conductivity."""
-        self.set_property(GrpcMaterialProperty.THERMAL_CONDUCTIVITY, GrpcValue(value))
+        self.set_property(GrpcMaterialProperty.THERMAL_CONDUCTIVITY, Value(value))
 
     @property
     def mass_density(self) -> float:
@@ -440,15 +435,14 @@ class Material(GrpcMaterialDef):
 
         """
         try:
-            value = self.get_property(GrpcMaterialProperty.MASS_DENSITY).value
-            return value
+            return Value(self.get_property(GrpcMaterialProperty.MASS_DENSITY))
         except:
             return 0.0
 
     @mass_density.setter
     def mass_density(self, value):
         """Set material mass density."""
-        self.set_property(GrpcMaterialProperty.MASS_DENSITY, GrpcValue(value))
+        self.set_property(GrpcMaterialProperty.MASS_DENSITY, Value(value))
 
     @property
     def youngs_modulus(self) -> float:
@@ -461,15 +455,14 @@ class Material(GrpcMaterialDef):
 
         """
         try:
-            value = self.get_property(GrpcMaterialProperty.YOUNGS_MODULUS).value
-            return value
+            return Value(self.get_property(GrpcMaterialProperty.YOUNGS_MODULUS))
         except:
             return 0.0
 
     @youngs_modulus.setter
     def youngs_modulus(self, value):
         """Set material young modulus."""
-        self.set_property(GrpcMaterialProperty.YOUNGS_MODULUS, GrpcValue(value))
+        self.set_property(GrpcMaterialProperty.YOUNGS_MODULUS, Value(value))
 
     @property
     def specific_heat(self) -> float:
@@ -481,14 +474,14 @@ class Material(GrpcMaterialDef):
             Material specific heat value.
         """
         try:
-            return self.get_property(GrpcMaterialProperty.SPECIFIC_HEAT).value
+            return Value(self.get_property(GrpcMaterialProperty.SPECIFIC_HEAT))
         except:
             return 0.0
 
     @specific_heat.setter
     def specific_heat(self, value):
         """Set material specific heat."""
-        self.set_property(GrpcMaterialProperty.SPECIFIC_HEAT, GrpcValue(value))
+        self.set_property(GrpcMaterialProperty.SPECIFIC_HEAT, Value(value))
 
     @property
     def poisson_ratio(self) -> float:
@@ -500,14 +493,14 @@ class Material(GrpcMaterialDef):
             Material poisson ratio value.
         """
         try:
-            return self.get_property(GrpcMaterialProperty.POISSONS_RATIO).value
+            return Value(self.get_property(GrpcMaterialProperty.POISSONS_RATIO))
         except:
             return 0.0
 
     @poisson_ratio.setter
     def poisson_ratio(self, value):
         """Set material poisson ratio."""
-        self.set_property(GrpcMaterialProperty.POISSONS_RATIO, GrpcValue(value))
+        self.set_property(GrpcMaterialProperty.POISSONS_RATIO, Value(value))
 
     @property
     def thermal_expansion_coefficient(self) -> float:
@@ -520,14 +513,14 @@ class Material(GrpcMaterialDef):
 
         """
         try:
-            return self.get_property(GrpcMaterialProperty.THERMAL_EXPANSION_COEFFICIENT).value
+            return Value(self.get_property(GrpcMaterialProperty.THERMAL_EXPANSION_COEFFICIENT))
         except:
             return 0.0
 
     @thermal_expansion_coefficient.setter
     def thermal_expansion_coefficient(self, value):
         """Set material thermal coefficient."""
-        self.set_property(GrpcMaterialProperty.THERMAL_EXPANSION_COEFFICIENT, GrpcValue(value))
+        self.set_property(GrpcMaterialProperty.THERMAL_EXPANSION_COEFFICIENT, Value(value))
 
     def set_debye_model(self):
         """Set Debye model on current material."""

pyedb/grpc/database/definition/package_def.py

@@ -22,11 +22,11 @@
 
 from ansys.edb.core.definition.package_def import PackageDef as GrpcPackageDef
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
-from ansys.edb.core.utility.value import Value as GrpcValue
 
-from pyedb.edb_logger import pyedb_logger
+from pyedb.generic.settings import settings
 from pyedb.grpc.database.utility.heat_sink import HeatSink
-from pyedb.misc.misc import deprecated_property
+from pyedb.grpc.database.utility.value import Value
+from pyedb.misc.decorators import deprecated_property
 
 
 class PackageDef(GrpcPackageDef):
@@ -82,7 +82,7 @@ class PackageDef(GrpcPackageDef):
         else:
             bbox = extent_bounding_box
         if bbox is None:
-            pyedb_logger.warning(
+            settings.logger.warning(
                 "Package creation uses bounding box but it cannot be inferred. "
                 "Please set argument 'component_part_name' or 'extent_bounding_box'."
             )
@@ -115,11 +115,11 @@ class PackageDef(GrpcPackageDef):
         float
             maximum power value.
         """
-        return super().maximum_power.value
+        return Value(super().maximum_power)
 
     @maximum_power.setter
     def maximum_power(self, value):
-        super(PackageDef, self.__class__).maximum_power.__set__(self, GrpcValue(value))
+        super(PackageDef, self.__class__).maximum_power.__set__(self, Value(value))
 
     @property
     def therm_cond(self) -> float:
@@ -131,11 +131,11 @@ class PackageDef(GrpcPackageDef):
             Thermal conductivity value.
 
         """
-        return super().thermal_conductivity.value
+        return Value(super().thermal_conductivity)
 
     @therm_cond.setter
     def therm_cond(self, value):
-        super(PackageDef, self.__class__).thermal_conductivity.__set__(self, GrpcValue(value))
+        super(PackageDef, self.__class__).thermal_conductivity.__set__(self, Value(value))
 
     @property
     def theta_jb(self) -> float:
@@ -146,11 +146,11 @@ class PackageDef(GrpcPackageDef):
         float
             Theta jb value.
         """
-        return super().theta_jb.value
+        return Value(super().theta_jb)
 
     @theta_jb.setter
     def theta_jb(self, value):
-        super(PackageDef, self.__class__).theta_jb.__set__(self, GrpcValue(value))
+        super(PackageDef, self.__class__).theta_jb.__set__(self, Value(value))
 
     @property
     def theta_jc(self) -> float:
@@ -161,11 +161,11 @@ class PackageDef(GrpcPackageDef):
         float
             Theta jc value.
         """
-        return super().theta_jc.value
+        return Value(super().theta_jc)
 
     @theta_jc.setter
     def theta_jc(self, value):
-        super(PackageDef, self.__class__).theta_jc.__set__(self, GrpcValue(value))
+        super(PackageDef, self.__class__).theta_jc.__set__(self, Value(value))
 
     @property
     def height(self) -> float:
@@ -176,11 +176,11 @@ class PackageDef(GrpcPackageDef):
         float
             Height value.
         """
-        return super().height.value
+        return Value(super().height)
 
     @height.setter
     def height(self, value):
-        super(PackageDef, self.__class__).height.__set__(self, GrpcValue(value))
+        super(PackageDef, self.__class__).height.__set__(self, Value(value))
 
     @property
     def heat_sink(self) -> HeatSink:
@@ -235,10 +235,10 @@ class PackageDef(GrpcPackageDef):
         super(PackageDef, self.__class__).heat_sink.__set__(
             self,
             GrpcHeatSink(
-                GrpcValue(fin_thickness),
-                GrpcValue(fin_spacing),
-                GrpcValue(fin_base_height),
-                GrpcValue(fin_height),
+                Value(fin_thickness),
+                Value(fin_spacing),
+                Value(fin_base_height),
+                Value(fin_height),
                 fin_orientation,
             ),
         )