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

pyedb/dotnet/database/stackup.py

@@ -68,20 +68,20 @@ class LayerCollection(object):
         self._pedb = pedb
 
         if edb_object:
-            self._edb_object = self._pedb.edb_api.cell._cell.LayerCollection(edb_object)
+            self._edb_object = self._pedb.core.cell._cell.LayerCollection(edb_object)
         else:
-            self._edb_object = self._pedb.edb_api.cell._cell.LayerCollection()
+            self._edb_object = self._pedb.core.cell._cell.LayerCollection()
 
         self._layer_type_set_mapping = {
-            "stackup_layer_set": self._pedb.edb_api.cell.layer_type_set.StackupLayerSet,
-            "signal_ayer_et": self._pedb.edb_api.cell.layer_type_set.SignalLayerSet,
-            "non_stackup_layer_set": self._pedb.edb_api.cell.layer_type_set.NonStackupLayerSet,
-            "all_layer_et": self._pedb.edb_api.cell.layer_type_set.AllLayerSet,
+            "stackup_layer_set": self._pedb.core.cell.layer_type_set.StackupLayerSet,
+            "signal_ayer_et": self._pedb.core.cell.layer_type_set.SignalLayerSet,
+            "non_stackup_layer_set": self._pedb.core.cell.layer_type_set.NonStackupLayerSet,
+            "all_layer_et": self._pedb.core.cell.layer_type_set.AllLayerSet,
         }
         self._lc_mode_mapping = {
-            "laminate": self._pedb.edb_api.cell._cell.LayerCollectionMode.Laminate,
-            "overlapping": self._pedb.edb_api.cell._cell.LayerCollectionMode.Overlapping,
-            "multizone": self._pedb.edb_api.cell._cell.LayerCollectionMode.MultiZone,
+            "laminate": self._pedb.core.cell._cell.LayerCollectionMode.Laminate,
+            "overlapping": self._pedb.core.cell._cell.LayerCollectionMode.Overlapping,
+            "multizone": self._pedb.core.cell._cell.LayerCollectionMode.MultiZone,
         }
 
     def update_layout(self):
@@ -95,7 +95,7 @@ class LayerCollection(object):
 
     def refresh_layer_collection(self):
         """Refresh layer collection from Edb. This method is run on demand after all edit operations on stackup."""
-        self._edb_object = self._pedb.edb_api.cell._cell.LayerCollection(self._pedb.layout.layer_collection)
+        self._edb_object = self._pedb.core.cell._cell.LayerCollection(self._pedb.layout.layer_collection)
         self._lc = self._edb_object
 
     def _add_layer(self, add_method, base_layer_name="", **kwargs):
@@ -238,7 +238,7 @@ class LayerCollection(object):
         return self._add_layer(add_method="add_layer_bottom", **kwargs)
 
     def set_layer_clone(self, layer_clone):
-        lc = self._pedb.edb_api.cell._cell.LayerCollection()  # empty layer collection
+        lc = self._pedb.core.cell._cell.LayerCollection()  # empty layer collection
         lc.SetMode(self._edb_object.GetMode())
         if self.mode.lower() == "laminate":
             add_method = lc.AddLayerBottom
@@ -282,7 +282,7 @@ class LayerCollection(object):
     @property
     def all_layers(self):
         self.refresh_layer_collection()
-        layer_list = list(self._edb_object.Layers(self._pedb.edb_api.cell.layer_type_set.AllLayerSet))
+        layer_list = list(self._edb_object.Layers(self._pedb.core.cell.layer_type_set.AllLayerSet))
         temp = dict()
         for i in layer_list:
             obj = layer_cast(self._pedb, i)
@@ -306,7 +306,7 @@ class LayerCollection(object):
 
     def find_layer_by_name(self, name: str):
         """Finds a layer with the given name."""
-        obj = self._pedb.edb_api.cell._cell.Layer.FindByName(self._edb_object, name)
+        obj = self._pedb.core.cell._cell.Layer.FindByName(self._edb_object, name)
         if obj.IsNull():
             raise ValueError("Layer with name '{}' was not found.".format(name))
         else:
@@ -337,7 +337,7 @@ class Stackup(LayerCollection):
         type
             Types of layers.
         """
-        return self._pedb.edb_api.cell.layer_type
+        return self._pedb.core.cell.layer_type
 
     @property
     def thickness(self):
@@ -592,7 +592,7 @@ class Stackup(LayerCollection):
 
     @mode.setter
     def mode(self, value):
-        mode = self._pedb.edb_api.Cell.LayerCollectionMode
+        mode = self._pedb.core.Cell.LayerCollectionMode
         if value == 0 or value == mode.Laminate or value == "Laminate":
             self._layer_collection.SetMode(mode.Laminate)
         elif value == 1 or value == mode.Overlapping or value == "Overlapping":
@@ -627,7 +627,7 @@ class Stackup(LayerCollection):
 
     @property
     def _edb_layer_list(self):
-        layer_list = list(self._layer_collection.Layers(self._pedb.edb_api.cell.layer_type_set.AllLayerSet))
+        layer_list = list(self._layer_collection.Layers(self._pedb.core.cell.layer_type_set.AllLayerSet))
         return [i.Clone() for i in layer_list]
 
     @property
@@ -638,7 +638,7 @@ class Stackup(LayerCollection):
         -------
         Dict[str, :class:`pyedb.dotnet.database.edb_data.layer_data.LayerEdbClass`]
         """
-        layer_type = self._pedb.edb_api.cell.layer_type.SignalLayer
+        layer_type = self._pedb.core.cell.layer_type.SignalLayer
         _lays = OrderedDict()
         for name, obj in self.layers.items():
             if obj._edb_layer.GetLayerType() == layer_type:
@@ -654,7 +654,7 @@ class Stackup(LayerCollection):
         dict[str, :class:`dotnet.database.edb_data.layer_data.EDBLayer`]
             Dictionary of dielectric layers.
         """
-        layer_type = self._pedb.edb_api.cell.layer_type.DielectricLayer
+        layer_type = self._pedb.core.cell.layer_type.DielectricLayer
         _lays = OrderedDict()
         for name, obj in self.layers.items():
             if obj._edb_layer.GetLayerType() == layer_type:
@@ -684,14 +684,13 @@ class Stackup(LayerCollection):
         if operation in ["change_position", "change_attribute", "change_name"]:
             lc_readonly = self._pedb.layout.layer_collection
             layers = [
-                i.Clone()
-                for i in list(list(lc_readonly.Layers(self._pedb.edb_api.cell.layer_type_set.StackupLayerSet)))
+                i.Clone() for i in list(list(lc_readonly.Layers(self._pedb.core.cell.layer_type_set.StackupLayerSet)))
             ]
             non_stackup = [
                 i.Clone()
-                for i in list(list(lc_readonly.Layers(self._pedb.edb_api.cell.layer_type_set.NonStackupLayerSet)))
+                for i in list(list(lc_readonly.Layers(self._pedb.core.cell.layer_type_set.NonStackupLayerSet)))
             ]
-            _lc = self._pedb.edb_api.cell._cell.LayerCollection()
+            _lc = self._pedb.core.cell._cell.LayerCollection()
             mode = lc_readonly.GetMode()
             _lc.SetMode(lc_readonly.GetMode())
             if str(mode) == "Overlapping":
@@ -727,11 +726,11 @@ class Stackup(LayerCollection):
 
     def _create_stackup_layer(self, layer_name, thickness, layer_type="signal"):
         if layer_type == "signal":
-            _layer_type = self._pedb.edb_api.cell.layer_type.SignalLayer
+            _layer_type = self._pedb.core.cell.layer_type.SignalLayer
         else:
-            _layer_type = self._pedb.edb_api.cell.layer_type.DielectricLayer
+            _layer_type = self._pedb.core.cell.layer_type.DielectricLayer
 
-        result = self._pedb.edb_api.cell._cell.StackupLayer(
+        result = self._pedb.core.cell._cell.StackupLayer(
             layer_name,
             _layer_type,
             self._edb_value(thickness),
@@ -743,39 +742,39 @@ class Stackup(LayerCollection):
 
     def _create_nonstackup_layer(self, layer_name, layer_type):
         if layer_type == "conducting":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.ConductingLayer
+            _layer_type = self._pedb.core.cell.layer_type.ConductingLayer
         elif layer_type == "airlines":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.AirlinesLayer
+            _layer_type = self._pedb.core.cell.layer_type.AirlinesLayer
         elif layer_type == "error":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.ErrorsLayer
+            _layer_type = self._pedb.core.cell.layer_type.ErrorsLayer
         elif layer_type == "symbol":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.SymbolLayer
+            _layer_type = self._pedb.core.cell.layer_type.SymbolLayer
         elif layer_type == "measure":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.MeasureLayer
+            _layer_type = self._pedb.core.cell.layer_type.MeasureLayer
         elif layer_type == "assembly":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.AssemblyLayer
+            _layer_type = self._pedb.core.cell.layer_type.AssemblyLayer
         elif layer_type == "silkscreen":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.SilkscreenLayer
+            _layer_type = self._pedb.core.cell.layer_type.SilkscreenLayer
         elif layer_type == "soldermask":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.SolderMaskLayer
+            _layer_type = self._pedb.core.cell.layer_type.SolderMaskLayer
         elif layer_type == "solderpaste":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.SolderPasteLayer
+            _layer_type = self._pedb.core.cell.layer_type.SolderPasteLayer
         elif layer_type == "glue":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.GlueLayer
+            _layer_type = self._pedb.core.cell.layer_type.GlueLayer
         elif layer_type == "wirebond":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.WirebondLayer
+            _layer_type = self._pedb.core.cell.layer_type.WirebondLayer
         elif layer_type == "user":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.UserLayer
+            _layer_type = self._pedb.core.cell.layer_type.UserLayer
         elif layer_type == "siwavehfsssolverregions":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.SIwaveHFSSSolverRegions
+            _layer_type = self._pedb.core.cell.layer_type.SIwaveHFSSSolverRegions
         elif layer_type == "outline":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.OutlineLayer
+            _layer_type = self._pedb.core.cell.layer_type.OutlineLayer
         elif layer_type == "postprocessing":  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.PostprocessingLayer
+            _layer_type = self._pedb.core.cell.layer_type.PostprocessingLayer
         else:  # pragma: no cover
-            _layer_type = self._pedb.edb_api.cell.layer_type.UndefinedLayerType
+            _layer_type = self._pedb.core.cell.layer_type.UndefinedLayerType
 
-        result = self._pedb.edb_api.cell.layer(layer_name, _layer_type)
+        result = self._pedb.core.cell.layer(layer_name, _layer_type)
         self.refresh_layer_collection()
         return result
 
@@ -901,7 +900,7 @@ class Stackup(LayerCollection):
         -------
 
         """
-        new_layer_collection = self._pedb.edb_api.Cell.LayerCollection()
+        new_layer_collection = self._pedb.core.Cell.LayerCollection()
         for lyr in self._edb_layer_list:
             if not (lyr.GetName() == name):
                 new_layer_collection.AddLayerBottom(lyr)
@@ -1122,9 +1121,9 @@ class Stackup(LayerCollection):
             ``True`` when successful, ``False`` when failed.
         """
         if only_metals:
-            input_layers = self._pedb.edb_api.cell.layer_type_set.SignalLayerSet
+            input_layers = self._pedb.core.cell.layer_type_set.SignalLayerSet
         else:
-            input_layers = self._pedb.edb_api.cell.layer_type_set.StackupLayerSet
+            input_layers = self._pedb.core.cell.layer_type_set.StackupLayerSet
 
         res, topl, topz, bottoml, bottomz = self._layer_collection.GetTopBottomStackupLayers(input_layers)
         return topl.GetName(), topz, bottoml.GetName(), bottomz
@@ -1146,18 +1145,18 @@ class Stackup(LayerCollection):
         """
         try:
             lc = self._layer_collection
-            new_lc = self._pedb.edb_api.Cell.LayerCollection()
+            new_lc = self._pedb.core.Cell.LayerCollection()
             lc_mode = lc.GetMode()
             new_lc.SetMode(lc_mode)
             max_elevation = 0.0
-            for layer in lc.Layers(self._pedb.edb_api.cell.layer_type_set.StackupLayerSet):
+            for layer in lc.Layers(self._pedb.core.cell.layer_type_set.StackupLayerSet):
                 if "RadBox" not in layer.GetName():  # Ignore RadBox
                     lower_elevation = layer.Clone().GetLowerElevation() * 1.0e6
                     upper_elevation = layer.Clone().GetUpperElevation() * 1.0e6
                     max_elevation = max([max_elevation, lower_elevation, upper_elevation])
 
             non_stackup_layers = []
-            for layer in lc.Layers(self._pedb.edb_api.cell.layer_type_set.AllLayerSet):
+            for layer in lc.Layers(self._pedb.core.cell.layer_type_set.AllLayerSet):
                 cloned_layer = layer.Clone()
                 if not cloned_layer.IsStackupLayer():
                     non_stackup_layers.append(cloned_layer)
@@ -1169,18 +1168,16 @@ class Stackup(LayerCollection):
                     cloned_layer.SetLowerElevation(val)
                     if (
                         cloned_layer.GetTopBottomAssociation()
-                        == self._pedb.edb_api.Cell.TopBottomAssociation.TopAssociated
+                        == self._pedb.core.Cell.TopBottomAssociation.TopAssociated
                     ):
-                        cloned_layer.SetTopBottomAssociation(
-                            self._pedb.edb_api.Cell.TopBottomAssociation.BottomAssociated
-                        )
+                        cloned_layer.SetTopBottomAssociation(self._pedb.core.Cell.TopBottomAssociation.BottomAssociated)
                     else:
-                        cloned_layer.SetTopBottomAssociation(self._pedb.edb_api.Cell.TopBottomAssociation.TopAssociated)
+                        cloned_layer.SetTopBottomAssociation(self._pedb.core.Cell.TopBottomAssociation.TopAssociated)
                     new_lc.AddStackupLayerAtElevation(cloned_layer)
 
             vialayers = [
                 lay
-                for lay in lc.Layers(self._pedb.edb_api.cell.layer_type_set.StackupLayerSet)
+                for lay in lc.Layers(self._pedb.core.cell.layer_type_set.StackupLayerSet)
                 if lay.Clone().IsViaLayer()
             ]
             for layer in vialayers:
@@ -1189,19 +1186,19 @@ class Stackup(LayerCollection):
                 lower_ref_name = cloned_via_layer.GetRefLayerName(False)
                 upper_ref = [
                     lay
-                    for lay in lc.Layers(self._pedb.edb_api.cell.layer_type_set.AllLayerSet)
+                    for lay in lc.Layers(self._pedb.core.cell.layer_type_set.AllLayerSet)
                     if lay.GetName() == upper_ref_name
                 ][0]
                 lower_ref = [
                     lay
-                    for lay in lc.Layers(self._pedb.edb_api.cell.layer_type_set.AllLayerSet)
+                    for lay in lc.Layers(self._pedb.core.cell.layer_type_set.AllLayerSet)
                     if lay.GetName() == lower_ref_name
                 ][0]
                 cloned_via_layer.SetRefLayer(lower_ref, True)
                 cloned_via_layer.SetRefLayer(upper_ref, False)
                 ref_layer_in_flipped_stackup = [
                     lay
-                    for lay in new_lc.Layers(self._pedb.edb_api.cell.layer_type_set.AllLayerSet)
+                    for lay in new_lc.Layers(self._pedb.core.cell.layer_type_set.AllLayerSet)
                     if lay.GetName() == upper_ref_name
                 ][0]
                 via_layer_lower_elevation = (
@@ -1246,7 +1243,7 @@ class Stackup(LayerCollection):
                         cmp_prop.SetDieProperty(die_prop)
                 cmp.SetComponentProperty(cmp_prop)
 
-            lay_list = list(new_lc.Layers(self._pedb.edb_api.cell.layer_type_set.SignalLayerSet))
+            lay_list = list(new_lc.Layers(self._pedb.core.cell.layer_type_set.SignalLayerSet))
             for padstack in list(self._pedb.padstacks.instances.values()):
                 start_layer_id = [lay.GetLayerId() for lay in list(lay_list) if lay.GetName() == padstack.start_layer]
                 stop_layer_id = [lay.GetLayerId() for lay in list(lay_list) if lay.GetName() == padstack.stop_layer]
@@ -1397,7 +1394,7 @@ class Stackup(LayerCollection):
             list_cells = self._pedb.copy_cells([edb_cell.api_object])
             edb_cell = list_cells[0]
         self._pedb.layout.cell.SetBlackBox(True)
-        cell_inst2 = self._pedb.edb_api.cell.hierarchy.cell_instance.Create(
+        cell_inst2 = self._pedb.core.cell.hierarchy.cell_instance.Create(
             edb_cell.GetLayout(), self._pedb.layout.cell.GetName(), self._pedb.active_layout
         )
         cell_trans = cell_inst2.GetTransform()
@@ -1411,11 +1408,11 @@ class Stackup(LayerCollection):
 
         if place_on_top:
             cell_inst2.SetPlacementLayer(
-                list(stackup_target.Layers(self._pedb.edb_api.cell.layer_type_set.SignalLayerSet))[0]
+                list(stackup_target.Layers(self._pedb.core.cell.layer_type_set.SignalLayerSet))[0]
             )
         else:
             cell_inst2.SetPlacementLayer(
-                list(stackup_target.Layers(self._pedb.edb_api.cell.layer_type_set.SignalLayerSet))[-1]
+                list(stackup_target.Layers(self._pedb.core.cell.layer_type_set.SignalLayerSet))[-1]
             )
         self.refresh_layer_collection()
         return True
@@ -1505,23 +1502,23 @@ class Stackup(LayerCollection):
             list_cells = self._pedb.copy_cells(edb_cell.api_object)
             edb_cell = list_cells[0]
         self._pedb.layout.cell.SetBlackBox(True)
-        cell_inst2 = self._pedb.edb_api.cell.hierarchy.cell_instance.Create(
+        cell_inst2 = self._pedb.core.cell.hierarchy.cell_instance.Create(
             edb_cell.GetLayout(), self._pedb.layout.cell.GetName(), self._pedb.active_layout
         )
 
-        stackup_target = self._pedb.edb_api.Cell.LayerCollection(edb_cell.GetLayout().GetLayerCollection())
-        stackup_source = self._pedb.edb_api.Cell.LayerCollection(self._pedb.layout.layer_collection)
+        stackup_target = self._pedb.core.Cell.LayerCollection(edb_cell.GetLayout().GetLayerCollection())
+        stackup_source = self._pedb.core.Cell.LayerCollection(self._pedb.layout.layer_collection)
 
         if place_on_top:
             cell_inst2.SetPlacementLayer(
-                list(stackup_target.Layers(self._pedb.edb_api.cell.layer_type_set.SignalLayerSet))[0]
+                list(stackup_target.Layers(self._pedb.core.cell.layer_type_set.SignalLayerSet))[0]
             )
         else:
             cell_inst2.SetPlacementLayer(
-                list(stackup_target.Layers(self._pedb.edb_api.cell.layer_type_set.SignalLayerSet))[-1]
+                list(stackup_target.Layers(self._pedb.core.cell.layer_type_set.SignalLayerSet))[-1]
             )
         cell_inst2.SetIs3DPlacement(True)
-        sig_set = self._pedb.edb_api.cell.layer_type_set.SignalLayerSet
+        sig_set = self._pedb.core.cell.layer_type_set.SignalLayerSet
         res = stackup_target.GetTopBottomStackupLayers(sig_set)
         target_top_elevation = res[2]
         target_bottom_elevation = res[4]
@@ -1656,23 +1653,23 @@ class Stackup(LayerCollection):
 
         instance_name = generate_unique_name(edb_cell.GetName(), n=2)
 
-        cell_inst2 = self._pedb.edb_api.cell.hierarchy.cell_instance.Create(
+        cell_inst2 = self._pedb.core.cell.hierarchy.cell_instance.Create(
             self._pedb.active_layout, instance_name, edb_cell.GetLayout()
         )
 
-        stackup_source = self._pedb.edb_api.Cell.LayerCollection(edb_cell.GetLayout().GetLayerCollection())
-        stackup_target = self._pedb.edb_api.Cell.LayerCollection(self._pedb.layout.layer_collection)
+        stackup_source = self._pedb.core.Cell.LayerCollection(edb_cell.GetLayout().GetLayerCollection())
+        stackup_target = self._pedb.core.Cell.LayerCollection(self._pedb.layout.layer_collection)
 
         if place_on_top:
             cell_inst2.SetPlacementLayer(
-                list(stackup_target.Layers(self._pedb.edb_api.cell.layer_type_set.SignalLayerSet))[0]
+                list(stackup_target.Layers(self._pedb.core.cell.layer_type_set.SignalLayerSet))[0]
             )
         else:
             cell_inst2.SetPlacementLayer(
-                list(stackup_target.Layers(self._pedb.edb_api.cell.layer_type_set.SignalLayerSet))[-1]
+                list(stackup_target.Layers(self._pedb.core.cell.layer_type_set.SignalLayerSet))[-1]
             )
         cell_inst2.SetIs3DPlacement(True)
-        sig_set = self._pedb.edb_api.cell.layer_type_set.SignalLayerSet
+        sig_set = self._pedb.core.cell.layer_type_set.SignalLayerSet
         res = stackup_target.GetTopBottomStackupLayers(sig_set)
         target_top_elevation = res[2]
         target_bottom_elevation = res[4]
@@ -1755,8 +1752,8 @@ class Stackup(LayerCollection):
         _angle = angle * math.pi / 180.0
         rotation_axis_to = self._pedb.point_3d(math.cos(_angle), -1 * math.sin(_angle), 0.0)
 
-        stackup_target = self._pedb.edb_api.cell._cell.LayerCollection(self._pedb.layout.layer_collection)
-        sig_set = self._pedb.edb_api.cell.layer_type_set.SignalLayerSet
+        stackup_target = self._pedb.core.cell._cell.LayerCollection(self._pedb.layout.layer_collection)
+        sig_set = self._pedb.core.cell.layer_type_set.SignalLayerSet
         res = stackup_target.GetTopBottomStackupLayers(sig_set)
         target_top_elevation = res[2]
         target_bottom_elevation = res[4]
@@ -1769,7 +1766,7 @@ class Stackup(LayerCollection):
         h_stackup = self._edb_value(elevation)
         location = self._pedb.point_3d(offset_x, offset_y, h_stackup)
 
-        mcad_model = self._pedb.edb_api.McadModel.Create3DComp(self._pedb.active_layout, a3dcomp_path)
+        mcad_model = self._pedb.core.McadModel.Create3DComp(self._pedb.active_layout, a3dcomp_path)
         if mcad_model.IsNull():  # pragma: no cover
             logger.error("Failed to create MCAD model from a3dcomp")
             return False
@@ -2002,7 +1999,7 @@ class Stackup(LayerCollection):
             if not str(layer_info.Dielectric_Fill) == "nan":
                 layer.dielectric_fill = layer_info.Dielectric_Fill
 
-        lc_new = self._pedb.edb_api.Cell.LayerCollection()
+        lc_new = self._pedb.core.Cell.LayerCollection()
         for name, _ in df.iterrows():
             layer = self.layers[name]
             lc_new.AddLayerBottom(layer._edb_layer)

pyedb/dotnet/database/utilities/heatsink.py

@@ -12,15 +12,15 @@ class HeatSink:
     def __init__(self, pedb, edb_object=None):
         self._pedb = pedb
         self._fin_orientation_type = {
-            "x_oriented": self._pedb.edb_api.utility.utility.HeatSinkFinOrientation.XOriented,
-            "y_oriented": self._pedb.edb_api.utility.utility.HeatSinkFinOrientation.YOriented,
-            "other_oriented": self._pedb.edb_api.utility.utility.HeatSinkFinOrientation.OtherOriented,
+            "x_oriented": self._pedb.core.utility.utility.HeatSinkFinOrientation.XOriented,
+            "y_oriented": self._pedb.core.utility.utility.HeatSinkFinOrientation.YOriented,
+            "other_oriented": self._pedb.core.utility.utility.HeatSinkFinOrientation.OtherOriented,
         }
 
         if edb_object:
             self._edb_object = edb_object
         else:
-            self._edb_object = self._pedb.edb_api.utility.utility.HeatSink()
+            self._edb_object = self._pedb.core.utility.utility.HeatSink()
 
     @property
     def fin_base_height(self):

pyedb/dotnet/database/utilities/obj_base.py

@@ -34,7 +34,7 @@ class BBox:
         else:
             point_1 = PointData(self._pedb, x=point_1[0], y=point_1[1])
             point_2 = PointData(self._pedb, x=point_2[0], y=point_2[1])
-            self._edb_object = Tuple[self._pedb.edb_api.Geometry.PointData, self._pedb.edb_api.Geometry.PointData](
+            self._edb_object = Tuple[self._pedb.core.Geometry.PointData, self._pedb.core.Geometry.PointData](
                 point_1._edb_object, point_2._edb_object
             )
 

pyedb/dotnet/database/utilities/value.py

@@ -0,0 +1,116 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+
+class Value(float):
+    """Class defining Edb Value properties."""
+
+    def __new__(cls, pedb, edb_obj):
+        temp = super().__new__(cls, float(round(edb_obj.ToDouble(), 9)))
+        temp._pedb = pedb
+        temp._edb_obj = edb_obj
+        return temp
+
+    def __str__(self):
+        """Returns the string of the variable.
+
+        Returns
+        -------
+        str
+        """
+        return self._edb_obj.ToString()
+
+    def __add__(self, other):
+        """Adds two Edb Values."""
+        edb_object = self._pedb.core.utility.value(f"({self._edb_obj.ToString()})+({str(other)})")
+        return self.__class__(self._pedb, edb_object)
+
+    def __radd__(self, other):
+        edb_object = self._pedb.core.utility.value(f"({str(other)})+({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def __sub__(self, other):
+        """Subtracts two Edb Values."""
+        edb_object = self._pedb.core.utility.value(f"({self._edb_obj.ToString()})-({str(other)})")
+        return self.__class__(self._pedb, edb_object)
+
+    def __rsub__(self, other):
+        edb_object = self._pedb.core.utility.value(f"({str(other)})-({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def __mul__(self, other):
+        """Multiplies two Edb Values."""
+        edb_object = self._pedb.core.utility.value(f"({self._edb_obj.ToString()})*({str(other)})")
+        return self.__class__(self._pedb, edb_object)
+
+    def __rmul__(self, other):
+        edb_object = self._pedb.core.utility.value(f"({str(other)})*({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def __truediv__(self, other):
+        """Divides two Edb Values."""
+        edb_object = self._pedb.core.utility.value(f"({self._edb_obj.ToString()})/({str(other)})")
+        return self.__class__(self._pedb, edb_object)
+
+    def __rtruediv__(self, other):
+        edb_object = self._pedb.core.utility.value(f"({str(other)})/({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def sqrt(self):
+        """Square root of the value."""
+        edb_object = self._pedb.core.utility.value(f"({self._edb_obj.ToString()})**0.5")
+        return self.__class__(self._pedb, edb_object)
+
+    def log10(self):
+        """Base-10 logarithm of the value."""
+        edb_object = self._pedb.core.utility.value(f"log10({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def sin(self):
+        """Sine of the value."""
+        edb_object = self._pedb.core.utility.value(f"sin({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def cos(self):
+        """Cosine of the value."""
+        edb_object = self._pedb.core.utility.value(f"cos({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def asin(self):
+        """Arcsine of the value."""
+        edb_object = self._pedb.core.utility.value(f"asin({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def acos(self):
+        """Arccosine of the value."""
+        edb_object = self._pedb.core.utility.value(f"acos({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def tan(self):
+        """Tangent of the value."""
+        edb_object = self._pedb.core.utility.value(f"tan({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def atan(self):
+        """Arctangent of the value."""
+        edb_object = self._pedb.core.utility.value(f"atan({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)