pyedb 0.54.0__py3-none-any.whl → 0.55.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.core.cell._cell.LayerCollection(edb_object)
+            self._edb_object = self._pedb.core.Cell.LayerCollection(edb_object)
         else:
-            self._edb_object = self._pedb.core.cell._cell.LayerCollection()
+            self._edb_object = self._pedb.core.Cell.LayerCollection()
 
         self._layer_type_set_mapping = {
-            "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,
+            "stackup_layer_set": self._pedb.core.Cell.LayerTypeSet.StackupLayerSet,
+            "signal_ayer_et": self._pedb.core.Cell.LayerTypeSet.SignalLayerSet,
+            "non_stackup_layer_set": self._pedb.core.Cell.LayerTypeSet.NonStackupLayerSet,
+            "all_layer_et": self._pedb.core.Cell.LayerTypeSet.AllLayerSet,
         }
         self._lc_mode_mapping = {
-            "laminate": self._pedb.core.cell._cell.LayerCollectionMode.Laminate,
-            "overlapping": self._pedb.core.cell._cell.LayerCollectionMode.Overlapping,
-            "multizone": self._pedb.core.cell._cell.LayerCollectionMode.MultiZone,
+            "laminate": self._pedb.core.Cell.LayerCollectionMode.Laminate,
+            "overlapping": self._pedb.core.Cell.LayerCollectionMode.Overlapping,
+            "multizone": self._pedb.core.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.core.cell._cell.LayerCollection(self._pedb.layout.layer_collection)
+        self._edb_object = self._pedb.core.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.core.cell._cell.LayerCollection()  # empty layer collection
+        lc = self._pedb.core.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.core.cell.layer_type_set.AllLayerSet))
+        layer_list = list(self._edb_object.Layers(self._pedb.core.Cell.LayerTypeSet.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.core.cell._cell.Layer.FindByName(self._edb_object, name)
+        obj = self._pedb.core.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.core.cell.layer_type
+        return self._pedb.core.Cell.LayerType
 
     @property
     def thickness(self):
@@ -627,7 +627,7 @@ class Stackup(LayerCollection):
 
     @property
     def _edb_layer_list(self):
-        layer_list = list(self._layer_collection.Layers(self._pedb.core.cell.layer_type_set.AllLayerSet))
+        layer_list = list(self._layer_collection.Layers(self._pedb.core.Cell.LayerTypeSet.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.core.cell.layer_type.SignalLayer
+        layer_type = self._pedb.core.Cell.LayerType.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.core.cell.layer_type.DielectricLayer
+        layer_type = self._pedb.core.Cell.LayerType.DielectricLayer
         _lays = OrderedDict()
         for name, obj in self.layers.items():
             if obj._edb_layer.GetLayerType() == layer_type:
@@ -684,13 +684,12 @@ 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.core.cell.layer_type_set.StackupLayerSet)))
+                i.Clone() for i in list(list(lc_readonly.Layers(self._pedb.core.Cell.LayerTypeSet.StackupLayerSet)))
             ]
             non_stackup = [
-                i.Clone()
-                for i in list(list(lc_readonly.Layers(self._pedb.core.cell.layer_type_set.NonStackupLayerSet)))
+                i.Clone() for i in list(list(lc_readonly.Layers(self._pedb.core.Cell.LayerTypeSet.NonStackupLayerSet)))
             ]
-            _lc = self._pedb.core.cell._cell.LayerCollection()
+            _lc = self._pedb.core.Cell.LayerCollection()
             mode = lc_readonly.GetMode()
             _lc.SetMode(lc_readonly.GetMode())
             if str(mode) == "Overlapping":
@@ -726,11 +725,11 @@ class Stackup(LayerCollection):
 
     def _create_stackup_layer(self, layer_name, thickness, layer_type="signal"):
         if layer_type == "signal":
-            _layer_type = self._pedb.core.cell.layer_type.SignalLayer
+            _layer_type = self._pedb.core.Cell.LayerType.SignalLayer
         else:
-            _layer_type = self._pedb.core.cell.layer_type.DielectricLayer
+            _layer_type = self._pedb.core.Cell.LayerType.DielectricLayer
 
-        result = self._pedb.core.cell._cell.StackupLayer(
+        result = self._pedb.core.Cell.StackupLayer(
             layer_name,
             _layer_type,
             self._edb_value(thickness),
@@ -742,39 +741,39 @@ class Stackup(LayerCollection):
 
     def _create_nonstackup_layer(self, layer_name, layer_type):
         if layer_type == "conducting":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.ConductingLayer
+            _layer_type = self._pedb.core.Cell.LayerType.ConductingLayer
         elif layer_type == "airlines":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.AirlinesLayer
+            _layer_type = self._pedb.core.Cell.LayerType.AirlinesLayer
         elif layer_type == "error":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.ErrorsLayer
+            _layer_type = self._pedb.core.Cell.LayerType.ErrorsLayer
         elif layer_type == "symbol":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.SymbolLayer
+            _layer_type = self._pedb.core.Cell.LayerType.SymbolLayer
         elif layer_type == "measure":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.MeasureLayer
+            _layer_type = self._pedb.core.Cell.LayerType.MeasureLayer
         elif layer_type == "assembly":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.AssemblyLayer
+            _layer_type = self._pedb.core.Cell.LayerType.AssemblyLayer
         elif layer_type == "silkscreen":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.SilkscreenLayer
+            _layer_type = self._pedb.core.Cell.LayerType.SilkscreenLayer
         elif layer_type == "soldermask":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.SolderMaskLayer
+            _layer_type = self._pedb.core.Cell.LayerType.SolderMaskLayer
         elif layer_type == "solderpaste":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.SolderPasteLayer
+            _layer_type = self._pedb.core.Cell.LayerType.SolderPasteLayer
         elif layer_type == "glue":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.GlueLayer
+            _layer_type = self._pedb.core.Cell.LayerType.GlueLayer
         elif layer_type == "wirebond":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.WirebondLayer
+            _layer_type = self._pedb.core.Cell.LayerType.WirebondLayer
         elif layer_type == "user":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.UserLayer
+            _layer_type = self._pedb.core.Cell.LayerType.UserLayer
         elif layer_type == "siwavehfsssolverregions":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.SIwaveHFSSSolverRegions
+            _layer_type = self._pedb.core.Cell.LayerType.SIwaveHFSSSolverRegions
         elif layer_type == "outline":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.OutlineLayer
+            _layer_type = self._pedb.core.Cell.LayerType.OutlineLayer
         elif layer_type == "postprocessing":  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.PostprocessingLayer
+            _layer_type = self._pedb.core.Cell.LayerType.PostprocessingLayer
         else:  # pragma: no cover
-            _layer_type = self._pedb.core.cell.layer_type.UndefinedLayerType
+            _layer_type = self._pedb.core.Cell.LayerType.UndefinedLayerType
 
-        result = self._pedb.core.cell.layer(layer_name, _layer_type)
+        result = self._pedb.core.Cell.layer(layer_name, _layer_type)
         self.refresh_layer_collection()
         return result
 
@@ -1121,9 +1120,9 @@ class Stackup(LayerCollection):
             ``True`` when successful, ``False`` when failed.
         """
         if only_metals:
-            input_layers = self._pedb.core.cell.layer_type_set.SignalLayerSet
+            input_layers = self._pedb.core.Cell.LayerTypeSet.SignalLayerSet
         else:
-            input_layers = self._pedb.core.cell.layer_type_set.StackupLayerSet
+            input_layers = self._pedb.core.Cell.LayerTypeSet.StackupLayerSet
 
         res, topl, topz, bottoml, bottomz = self._layer_collection.GetTopBottomStackupLayers(input_layers)
         return topl.GetName(), topz, bottoml.GetName(), bottomz
@@ -1149,14 +1148,14 @@ class Stackup(LayerCollection):
             lc_mode = lc.GetMode()
             new_lc.SetMode(lc_mode)
             max_elevation = 0.0
-            for layer in lc.Layers(self._pedb.core.cell.layer_type_set.StackupLayerSet):
+            for layer in lc.Layers(self._pedb.core.Cell.LayerTypeSet.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.core.cell.layer_type_set.AllLayerSet):
+            for layer in lc.Layers(self._pedb.core.Cell.LayerTypeSet.AllLayerSet):
                 cloned_layer = layer.Clone()
                 if not cloned_layer.IsStackupLayer():
                     non_stackup_layers.append(cloned_layer)
@@ -1176,9 +1175,7 @@ class Stackup(LayerCollection):
                     new_lc.AddStackupLayerAtElevation(cloned_layer)
 
             vialayers = [
-                lay
-                for lay in lc.Layers(self._pedb.core.cell.layer_type_set.StackupLayerSet)
-                if lay.Clone().IsViaLayer()
+                lay for lay in lc.Layers(self._pedb.core.Cell.LayerTypeSet.StackupLayerSet) if lay.Clone().IsViaLayer()
             ]
             for layer in vialayers:
                 cloned_via_layer = layer.Clone()
@@ -1186,19 +1183,19 @@ class Stackup(LayerCollection):
                 lower_ref_name = cloned_via_layer.GetRefLayerName(False)
                 upper_ref = [
                     lay
-                    for lay in lc.Layers(self._pedb.core.cell.layer_type_set.AllLayerSet)
+                    for lay in lc.Layers(self._pedb.core.Cell.LayerTypeSet.AllLayerSet)
                     if lay.GetName() == upper_ref_name
                 ][0]
                 lower_ref = [
                     lay
-                    for lay in lc.Layers(self._pedb.core.cell.layer_type_set.AllLayerSet)
+                    for lay in lc.Layers(self._pedb.core.Cell.LayerTypeSet.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.core.cell.layer_type_set.AllLayerSet)
+                    for lay in new_lc.Layers(self._pedb.core.Cell.LayerTypeSet.AllLayerSet)
                     if lay.GetName() == upper_ref_name
                 ][0]
                 via_layer_lower_elevation = (
@@ -1243,7 +1240,7 @@ class Stackup(LayerCollection):
                         cmp_prop.SetDieProperty(die_prop)
                 cmp.SetComponentProperty(cmp_prop)
 
-            lay_list = list(new_lc.Layers(self._pedb.core.cell.layer_type_set.SignalLayerSet))
+            lay_list = list(new_lc.Layers(self._pedb.core.Cell.LayerTypeSet.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]
@@ -1391,10 +1388,10 @@ class Stackup(LayerCollection):
         _offset_y = self._edb_value(offset_y)
 
         if edb_cell.GetName() not in self._pedb.cell_names:
-            list_cells = self._pedb.copy_cells([edb_cell.api_object])
+            list_cells = self._pedb.copy_cells([edb_cell])
             edb_cell = list_cells[0]
         self._pedb.layout.cell.SetBlackBox(True)
-        cell_inst2 = self._pedb.core.cell.hierarchy.cell_instance.Create(
+        cell_inst2 = self._pedb.core.Cell.Hierarchy.CellInstance.Create(
             edb_cell.GetLayout(), self._pedb.layout.cell.GetName(), self._pedb.active_layout
         )
         cell_trans = cell_inst2.GetTransform()
@@ -1408,11 +1405,11 @@ class Stackup(LayerCollection):
 
         if place_on_top:
             cell_inst2.SetPlacementLayer(
-                list(stackup_target.Layers(self._pedb.core.cell.layer_type_set.SignalLayerSet))[0]
+                list(stackup_target.Layers(self._pedb.core.Cell.LayerTypeSet.SignalLayerSet))[0]
             )
         else:
             cell_inst2.SetPlacementLayer(
-                list(stackup_target.Layers(self._pedb.core.cell.layer_type_set.SignalLayerSet))[-1]
+                list(stackup_target.Layers(self._pedb.core.Cell.LayerTypeSet.SignalLayerSet))[-1]
             )
         self.refresh_layer_collection()
         return True
@@ -1499,10 +1496,10 @@ class Stackup(LayerCollection):
         _offset_y = self._edb_value(offset_y)
 
         if edb_cell.GetName() not in self._pedb.cell_names:
-            list_cells = self._pedb.copy_cells(edb_cell.api_object)
+            list_cells = self._pedb.copy_cells(edb_cell)
             edb_cell = list_cells[0]
         self._pedb.layout.cell.SetBlackBox(True)
-        cell_inst2 = self._pedb.core.cell.hierarchy.cell_instance.Create(
+        cell_inst2 = self._pedb.core.Cell.Hierarchy.CellInstance.Create(
             edb_cell.GetLayout(), self._pedb.layout.cell.GetName(), self._pedb.active_layout
         )
 
@@ -1511,14 +1508,14 @@ class Stackup(LayerCollection):
 
         if place_on_top:
             cell_inst2.SetPlacementLayer(
-                list(stackup_target.Layers(self._pedb.core.cell.layer_type_set.SignalLayerSet))[0]
+                list(stackup_target.Layers(self._pedb.core.Cell.LayerTypeSet.SignalLayerSet))[0]
             )
         else:
             cell_inst2.SetPlacementLayer(
-                list(stackup_target.Layers(self._pedb.core.cell.layer_type_set.SignalLayerSet))[-1]
+                list(stackup_target.Layers(self._pedb.core.Cell.LayerTypeSet.SignalLayerSet))[-1]
             )
         cell_inst2.SetIs3DPlacement(True)
-        sig_set = self._pedb.core.cell.layer_type_set.SignalLayerSet
+        sig_set = self._pedb.core.Cell.LayerTypeSet.SignalLayerSet
         res = stackup_target.GetTopBottomStackupLayers(sig_set)
         target_top_elevation = res[2]
         target_bottom_elevation = res[4]
@@ -1637,7 +1634,7 @@ class Stackup(LayerCollection):
         _offset_y = self._edb_value(offset_y)
 
         if edb_cell.GetName() not in self._pedb.cell_names:
-            list_cells = self._pedb.copy_cells(edb_cell.api_object)
+            list_cells = self._pedb.copy_cells(edb_cell)
             edb_cell = list_cells[0]
         for cell in list(self._pedb.active_db.CircuitCells):
             if cell.GetName() == edb_cell.GetName():
@@ -1653,7 +1650,7 @@ class Stackup(LayerCollection):
 
         instance_name = generate_unique_name(edb_cell.GetName(), n=2)
 
-        cell_inst2 = self._pedb.core.cell.hierarchy.cell_instance.Create(
+        cell_inst2 = self._pedb.core.Cell.Hierarchy.CellInstance.Create(
             self._pedb.active_layout, instance_name, edb_cell.GetLayout()
         )
 
@@ -1662,14 +1659,14 @@ class Stackup(LayerCollection):
 
         if place_on_top:
             cell_inst2.SetPlacementLayer(
-                list(stackup_target.Layers(self._pedb.core.cell.layer_type_set.SignalLayerSet))[0]
+                list(stackup_target.Layers(self._pedb.core.Cell.LayerTypeSet.SignalLayerSet))[0]
             )
         else:
             cell_inst2.SetPlacementLayer(
-                list(stackup_target.Layers(self._pedb.core.cell.layer_type_set.SignalLayerSet))[-1]
+                list(stackup_target.Layers(self._pedb.core.Cell.LayerTypeSet.SignalLayerSet))[-1]
             )
         cell_inst2.SetIs3DPlacement(True)
-        sig_set = self._pedb.core.cell.layer_type_set.SignalLayerSet
+        sig_set = self._pedb.core.Cell.LayerTypeSet.SignalLayerSet
         res = stackup_target.GetTopBottomStackupLayers(sig_set)
         target_top_elevation = res[2]
         target_bottom_elevation = res[4]
@@ -1752,8 +1749,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.core.cell._cell.LayerCollection(self._pedb.layout.layer_collection)
-        sig_set = self._pedb.core.cell.layer_type_set.SignalLayerSet
+        stackup_target = self._pedb.core.Cell.LayerCollection(self._pedb.layout.layer_collection)
+        sig_set = self._pedb.core.Cell.LayerTypeSet.SignalLayerSet
         res = stackup_target.GetTopBottomStackupLayers(sig_set)
         target_top_elevation = res[2]
         target_bottom_elevation = res[4]
@@ -2245,10 +2242,62 @@ class Stackup(LayerCollection):
             ``True`` when successful, ``False`` when failed.
         """
 
-        self._edb_object.ImportFromControlFile(file_path)
-        flag = self._pedb.layout._edb_object.SetLayerCollection(self._edb_object)
-        self.refresh_layer_collection()
-        return flag
+        if not colors:
+            self._pedb.logger.error("Matplotlib is needed. Please, install it first.")
+            return False
+        tree = ET.parse(file_path)
+        root = tree.getroot()
+        stackup = root.find("Stackup")
+        stackup_dict = {}
+        if stackup.find("Materials"):
+            mats = []
+            for m in stackup.find("Materials").findall("Material"):
+                temp = dict()
+                for i in list(m):
+                    value = list(i)[0].text
+                    temp[i.tag] = value
+                mat = {"name": m.attrib["Name"]}
+                temp_dict = {
+                    "Permittivity": "permittivity",
+                    "Conductivity": "conductivity",
+                    "DielectricLossTangent": "dielectric_loss_tangent",
+                }
+                for i in temp_dict.keys():
+                    value = temp.get(i, None)
+                    if value:
+                        mat[temp_dict[i]] = value
+                mats.append(mat)
+            stackup_dict["materials"] = mats
+
+        stackup_section = stackup.find("Layers")
+        if stackup_section:
+            length_unit = stackup_section.attrib["LengthUnit"]
+            layers = []
+            for l in stackup.find("Layers").findall("Layer"):
+                temp = l.attrib
+                layer = dict()
+                temp_dict = {
+                    "Name": "name",
+                    "Color": "color",
+                    "Material": "material",
+                    "Thickness": "thickness",
+                    "Type": "type",
+                    "FillMaterial": "fill_material",
+                }
+                for i in temp_dict.keys():
+                    value = temp.get(i, None)
+                    if value:
+                        if i == "Thickness":
+                            value = str(round(float(value), 6)) + length_unit
+                        value = "signal" if value == "conductor" else value
+                        if i == "Color":
+                            value = [int(x * 255) for x in list(colors.to_rgb(value))]
+                        layer[temp_dict[i]] = value
+                layers.append(layer)
+            stackup_dict["layers"] = layers
+        cfg = {"stackup": stackup_dict}
+        self._pedb.configuration.load(cfg)
+        return self._pedb.configuration.run()
 
     def _export_xml(self, file_path):
         """Export stackup information to an external XMLfile.
@@ -2812,3 +2861,22 @@ class Stackup(LayerCollection):
         elif show:
             plt.show()
         return plt
+
+    def load_from_xml(self, file_path):
+        """Load stackup from a XML file.
+
+        Parameters
+        ----------
+        file_path: str
+            Path to external XML file.
+
+        Returns
+        -------
+        bool
+            ``True`` when successful, ``False`` when failed.
+        """
+
+        self._edb_object.ImportFromControlFile(file_path)
+        flag = self._pedb.layout._edb_object.SetLayerCollection(self._edb_object)
+        self.refresh_layer_collection()
+        return flag

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.core.utility.utility.HeatSinkFinOrientation.XOriented,
-            "y_oriented": self._pedb.core.utility.utility.HeatSinkFinOrientation.YOriented,
-            "other_oriented": self._pedb.core.utility.utility.HeatSinkFinOrientation.OtherOriented,
+            "x_oriented": self._pedb.core.Utility.HeatSinkFinOrientation.XOriented,
+            "y_oriented": self._pedb.core.Utility.HeatSinkFinOrientation.YOriented,
+            "other_oriented": self._pedb.core.Utility.HeatSinkFinOrientation.OtherOriented,
         }
 
         if edb_object:
             self._edb_object = edb_object
         else:
-            self._edb_object = self._pedb.core.utility.utility.HeatSink()
+            self._edb_object = self._pedb.core.Utility.HeatSink()
 
     @property
     def fin_base_height(self):

pyedb/dotnet/database/utilities/obj_base.py

@@ -32,8 +32,8 @@ class BBox:
         if edb_object:
             self._edb_object = edb_object
         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])
+            point_1 = PointData.create_from_xy(self._pedb, x=point_1[0], y=point_1[1])
+            point_2 = PointData.create_from_xy(self._pedb, x=point_2[0], y=point_2[1])
             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/simulation_setup.py

@@ -86,7 +86,7 @@ class SimulationSetup(object):
             "kNumSetupTypes": None,
         }
 
-        if float(self._pedb.edbversion) >= 2024.2:
+        if float(self._pedb.version) >= 2024.2:
             self._simulation_setup_type.update(
                 {
                     "kRaptorX": self._pedb.simsetupdata.RaptorX.RaptorXSimulationSettings,
@@ -169,7 +169,7 @@ class SimulationSetup(object):
             "kNumSetupTypes": None,
         }
 
-        if float(self._pedb.edbversion) >= 2024.2:
+        if float(self._pedb.version) >= 2024.2:
             setup_type_mapping["kRaptorX"] = utility.RaptorXSimulationSetup
             setup_type_mapping["kHFSSPI"] = utility.HFSSPISimulationSetup
         sim_setup_type = self.sim_setup_info.sim_setup_type

pyedb/dotnet/database/utilities/value.py

@@ -41,76 +41,76 @@ class Value(float):
 
     def __add__(self, other):
         """Adds two Edb Values."""
-        edb_object = self._pedb.core.utility.value(f"({self._edb_obj.ToString()})+({str(other)})")
+        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()})")
+        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)})")
+        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()})")
+        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)})")
+        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()})")
+        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)})")
+        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()})")
+        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")
+        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()})")
+        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()})")
+        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()})")
+        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()})")
+        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()})")
+        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()})")
+        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()})")
+        edb_object = self._pedb.core.Utility.Value(f"atan({self._edb_obj.ToString()})")
         return self.__class__(self._pedb, edb_object)