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

pyedb/grpc/database/ports/ports.py

@@ -20,14 +20,13 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from ansys.edb.core.utility.value import Value as GrpcValue
-
 from pyedb.dotnet.database.cell.terminal.terminal import Terminal
 from pyedb.grpc.database.terminal.bundle_terminal import BundleTerminal
 from pyedb.grpc.database.terminal.edge_terminal import EdgeTerminal
 from pyedb.grpc.database.terminal.padstack_instance_terminal import (
     PadstackInstanceTerminal,
 )
+from pyedb.grpc.database.utility.value import Value
 
 
 class GapPort(EdgeTerminal):
@@ -60,7 +59,7 @@ class GapPort(EdgeTerminal):
         float
             Magnitude value.
         """
-        return self._edb_object.source_amplitude.value
+        return Value(self._edb_object.source_amplitude, self._pedb.active_cell)
 
     @property
     def phase(self) -> float:
@@ -71,7 +70,7 @@ class GapPort(EdgeTerminal):
         float
             Phase value.
         """
-        return self._edb_object.source_phase.value
+        return Value(self._edb_object.source_phase, self._pedb.active_cell)
 
     @property
     def renormalize(self) -> bool:
@@ -236,12 +235,12 @@ class WavePort(EdgeTerminal):
         float
             deembed value.
         """
-        return self._edb_object.port_post_processing_prop.deembed_length.value
+        return Value(self._edb_object.port_post_processing_prop.deembed_length, self._pedb.active_cell)
 
     @deembed_length.setter
     def deembed_length(self, value):
         p = self._edb_object.port_post_processing_prop
-        p.deembed_length = GrpcValue(value)
+        p.deembed_length = Value(value)
         self._edb_object.port_post_processing_prop = p
 
 

pyedb/grpc/database/primitive/bondwire.py

@@ -25,7 +25,8 @@ from ansys.edb.core.primitive.bondwire import (
 )
 from ansys.edb.core.primitive.bondwire import Bondwire as GrpcBondWire
 from ansys.edb.core.primitive.bondwire import BondwireType as GrpcBondWireType
-from ansys.edb.core.utility.value import Value as GrpcValue
+
+from pyedb.grpc.database.utility.value import Value
 
 
 class Bondwire(GrpcBondWire):
@@ -113,11 +114,11 @@ class Bondwire(GrpcBondWire):
         float
             Cross section height.
         """
-        return super().cross_section_height.value
+        return Value(super().cross_section_height)
 
     @cross_section_height.setter
     def cross_section_height(self, cross_section_height):
-        super(Bondwire, self.__class__).cross_section_height.__set__(self, GrpcValue(cross_section_height))
+        super(Bondwire, self.__class__).cross_section_height.__set__(self, Value(cross_section_height))
 
     # @property
     # def trajectory(self):
@@ -134,11 +135,11 @@ class Bondwire(GrpcBondWire):
     #     **x1** : X value of the end point.
     #     **y1** : Y value of the end point.
     #     """
-    #     return [i.value for i in self.get_traj()]
+    #     return [Value(i) for i in self.get_traj()]
     #
     # @trajectory.setter
     # def trajectory(self, value):
-    #     values = [GrpcValue(i) for i in value]
+    #     values = [Value(i) for i in value]
     #     self.set_traj(values[0], values[1], values[2], values[3])
 
     @property
@@ -150,11 +151,11 @@ class Bondwire(GrpcBondWire):
         float
             Width value.
         """
-        return super().width.value
+        return Value(super().width)
 
     @width.setter
     def width(self, width):
-        super(Bondwire, self.__class__).width.__set__(self, GrpcValue(width))
+        super(Bondwire, self.__class__).width.__set__(self, Value(width))
 
     # @property
     # def start_elevation(self):

pyedb/grpc/database/primitive/circle.py

@@ -22,9 +22,9 @@
 
 
 from ansys.edb.core.primitive.circle import Circle as GrpcCircle
-from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.grpc.database.primitive.primitive import Primitive
+from pyedb.grpc.database.utility.value import Value
 
 
 class Circle(GrpcCircle, Primitive):
@@ -33,7 +33,7 @@ class Circle(GrpcCircle, Primitive):
         Primitive.__init__(self, pedb, edb_object)
         self._pedb = pedb
 
-    def get_parameters(self):
+    def get_parameters(self) -> tuple[float, float, float]:
         """Returns parameters.
 
         Returns
@@ -57,7 +57,7 @@ class Circle(GrpcCircle, Primitive):
 
         """
         params = super().get_parameters()
-        return params[0].value, params[1].value, params[2].value
+        return Value(params[0]), Value(params[1]), Value(params[2])
 
     def set_parameters(self, center_x, center_y, radius):
         """Set parameters.
@@ -72,4 +72,4 @@ class Circle(GrpcCircle, Primitive):
             Circle radius.
 
         """
-        super().set_parameters(GrpcValue(center_x), GrpcValue(center_y), GrpcValue(radius))
+        super().set_parameters(Value(center_x), Value(center_y), Value(radius))

pyedb/grpc/database/primitive/padstack_instance.py

@@ -22,23 +22,28 @@
 
 import math
 import re
+import warnings
 
 from ansys.edb.core.database import ProductIdType as GrpcProductIdType
 from ansys.edb.core.geometry.point_data import PointData as GrpcPointData
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
 from ansys.edb.core.hierarchy.pin_group import PinGroup as GrpcPinGroup
+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.padstack_instance import (
     PadstackInstance as GrpcPadstackInstance,
 )
 from ansys.edb.core.terminal.pin_group_terminal import (
     PinGroupTerminal as GrpcPinGroupTerminal,
 )
-from ansys.edb.core.utility.value import Value as GrpcValue
 
+from pyedb.generic.general_methods import generate_unique_name
 from pyedb.grpc.database.definition.padstack_def import PadstackDef
+from pyedb.grpc.database.modeler import Circle
 from pyedb.grpc.database.terminal.padstack_instance_terminal import (
     PadstackInstanceTerminal,
 )
+from pyedb.grpc.database.utility.value import Value
 from pyedb.modeler.geometry_operators import GeometryOperators
 
 
@@ -67,6 +72,16 @@ class PadstackInstance(GrpcPadstackInstance):
         self._pedb = pedb
         self._object_instance = None
 
+    @property
+    def is_pin(self):
+        """Property added for backward compatibility with earlier versions of pyEDB."""
+        return self.is_layout_pin
+
+    @is_pin.setter
+    def is_pin(self, value):
+        """Property added for backward compatibility with earlier versions of pyEDB."""
+        self.is_layout_pin = value
+
     @property
     def definition(self) -> PadstackDef:
         """Padstack definition.
@@ -108,6 +123,77 @@ class PadstackInstance(GrpcPadstackInstance):
             term = PadstackInstanceTerminal(self._pedb, term)
         return term if not term.is_null else None
 
+    def set_backdrill_top(self, drill_depth, drill_diameter, offset=0.0):
+        """Set backdrill from top.
+
+        .deprecated:: 0.55.0
+        Use :method:`set_back_drill_by_depth` instead.
+
+        Parameters
+        ----------
+        drill_depth : str
+            Name of the drill to layer.
+        drill_diameter : float, str
+            Diameter of backdrill size.
+        offset : str, optional.
+            offset with respect to the layer to drill to.
+
+        Returns
+        -------
+        bool
+            True if success, False otherwise.
+        """
+        warnings.warn(
+            "`set_backdrill_top` is deprecated. Use `set_back_drill_by_depth` or " "`set_back_drill_by_layer` instead.",
+            DeprecationWarning,
+        )
+        if isinstance(drill_depth, str):
+            if drill_depth in self._pedb.stackup.layers:
+                return self.set_back_drill_by_layer(
+                    drill_to_layer=self._pedb.stackup.layers[drill_depth],
+                    offset=Value(offset),
+                    diameter=Value(drill_diameter),
+                    from_bottom=False,
+                )
+            else:
+                return self.set_back_drill_by_depth(Value(drill_depth), Value(drill_diameter), from_bottom=False)
+
+    def set_backdrill_bottom(self, drill_depth, drill_diameter, offset=0.0):
+        """Set backdrill from bottom.
+
+        .deprecated: 0.55.0
+        Use: method:`set_back_drill_by_depth` instead.
+
+        Parameters
+        ----------
+        drill_depth : str
+            Name of the drill to layer.
+        drill_diameter : float, str
+            Diameter of backdrill size.
+        offset : str, optional.
+            offset with respect to the layer to drill to.
+
+        Returns
+        -------
+        bool
+            True if success, False otherwise.
+        """
+        warnings.warn(
+            "`set_backdrill_bottom` is deprecated. Use `set_back_drill_by_depth` or "
+            "`set_back_drill_by_layer` instead.",
+            DeprecationWarning,
+        )
+        if isinstance(drill_depth, str):
+            if drill_depth in self._pedb.stackup.layers:
+                return self.set_back_drill_by_layer(
+                    drill_to_layer=self._pedb.stackup.layers[drill_depth],
+                    offset=Value(offset),
+                    diameter=Value(drill_diameter),
+                    from_bottom=True,
+                )
+            else:
+                return self.set_back_drill_by_depth(Value(drill_depth), Value(drill_diameter), from_bottom=True)
+
     def create_terminal(self, name=None) -> PadstackInstanceTerminal:
         """Create a padstack instance terminal.
 
@@ -266,7 +352,7 @@ class PadstackInstance(GrpcPadstackInstance):
     @_em_properties.setter
     def _em_properties(self, em_prop):
         """Set EM properties"""
-        pid = self._pedb.edb_api.ProductId.Designer
+        pid = self._pedb.core.ProductId.Designer
         self.set_product_property(pid, 18, em_prop)
 
     @property
@@ -500,25 +586,28 @@ class PadstackInstance(GrpcPadstackInstance):
         list
             List of ``[x, y]`` coordinates for the padstack instance position.
         """
-        position = self.get_position_and_rotation()
-        if self.component:
-            out2 = self.component.transform.transform_point(GrpcPointData(position[:2]))
-            self._position = [round(out2[0].value, 6), round(out2[1].value, 6)]
-        else:
-            self._position = [round(pt.value, 6) for pt in position[:2]]
-        return self._position
+        try:
+            position = self.get_position_and_rotation()
+            if self.component:
+                out2 = self.component.transform.transform_point(GrpcPointData(position[:2]))
+                self._position = [Value(out2[0]), Value(out2[1])]
+            else:
+                self._position = [Value(pt) for pt in position[:2]]
+            return self._position
+        except Exception:
+            return False
 
     @position.setter
     def position(self, value):
         pos = []
         for v in value:
             if isinstance(v, (float, int, str)):
-                pos.append(GrpcValue(v, self._pedb.active_cell))
+                pos.append(Value(v, self._pedb.active_cell))
             else:
                 pos.append(v)
         point_data = GrpcPointData(pos[0], pos[1])
         self.set_position_and_rotation(
-            x=point_data.x, y=point_data.y, rotation=GrpcValue(self.rotation, self._pedb.active_cell)
+            x=point_data.x, y=point_data.y, rotation=Value(self.rotation, self._pedb.active_cell)
         )
 
     @property
@@ -530,7 +619,7 @@ class PadstackInstance(GrpcPadstackInstance):
         float
             Rotatation value for the padstack instance.
         """
-        return self.get_position_and_rotation()[-1].value
+        return Value(self.get_position_and_rotation()[-1])
 
     @property
     def name(self) -> str:
@@ -684,6 +773,85 @@ class PadstackInstance(GrpcPadstackInstance):
     def side_number(self, value):
         self._side_number = self.set_product_property(GrpcProductIdType.HFSS_3D_LAYOUT, 21, value)
 
+    def split(self) -> list:
+        """Split padstack instance into multiple instances. The new instances only connect adjacent layers."""
+        pdef_name = self.padstack_definition
+        position = self.position
+        net_name = self.net_name
+        name = self.name
+        stackup_layer_range = list(self._pedb.stackup.signal_layers.keys())
+        start_idx = stackup_layer_range.index(self.start_layer)
+        stop_idx = stackup_layer_range.index(self.stop_layer)
+        temp = []
+        for idx, (l1, l2) in enumerate(
+            list(zip(stackup_layer_range[start_idx:stop_idx], stackup_layer_range[start_idx + 1 : stop_idx + 1]))
+        ):
+            pd_inst = self._pedb.padstacks.place(
+                position, pdef_name, net_name, f"{name}_{idx}", fromlayer=l1, tolayer=l2
+            )
+            temp.append(pd_inst)
+        self.delete()
+        return temp
+
+    def convert_hole_to_conical_shape(self, angle=75):
+        """Convert actual padstack instance to microvias 3D Objects with a given aspect ratio.
+
+        Parameters
+        ----------
+        angle : float, optional
+            Angle of laser penetration in degrees. The angle defines the lowest hole diameter with this formula:
+            HoleDiameter -2*tan(laser_angle* Hole depth). Hole depth is the height of the via (dielectric thickness).
+            The default is ``75``.
+            The lowest hole is ``0.75*HoleDepth/HoleDiam``.
+
+        Returns
+        -------
+        """
+        stackup_layers = self._pedb.stackup.stackup_layers
+        signal_layers = self._pedb.stackup.signal_layers
+        layer_idx = list(signal_layers.keys()).index(self.start_layer)
+
+        _layer_idx = list(stackup_layers.keys()).index(self.start_layer)
+        diel_layer_idx = list(stackup_layers.keys())[_layer_idx + 1]
+        diel_thickness = stackup_layers[diel_layer_idx].thickness
+
+        rad_large = self.definition.hole_diameter / 2
+        rad_small = rad_large - diel_thickness * 1 / math.tan(math.radians(angle))
+
+        if layer_idx + 1 < len(signal_layers) / 2:  # upper half of stack
+            rad_u = rad_large
+            rad_l = rad_small
+        else:
+            rad_u = rad_small
+            rad_l = rad_large
+
+        layout = self._pedb.active_layout
+        cloned_circle = Circle.create(
+            layout,
+            self.start_layer,
+            self.net,
+            Value(self.position[0]),
+            Value(self.position[1]),
+            Value(rad_u),
+        )
+        cloned_circle2 = Circle.create(
+            layout,
+            self.stop_layer,
+            self.net,
+            Value(self.position[0]),
+            Value(self.position[1]),
+            Value(rad_l),
+        )
+
+        s3d = GrpcStructure3D.create(layout, generate_unique_name("via3d_" + self.aedt_name.replace("via_", ""), n=3))
+        s3d.add_member(cloned_circle)
+        s3d.add_member(cloned_circle2)
+        s3d.set_material(self.definition.material)
+        s3d.mesh_closure = GrpcMeshClosure.ENDS_CLOSED
+        hole_override_enabled = True
+        hole_override_diam = 0
+        self.set_hole_overrides(hole_override_enabled, Value(hole_override_diam))
+
     def get_backdrill_type(self, from_bottom=True):
         """Return backdrill type
         Parameters
@@ -714,8 +882,8 @@ class PadstackInstance(GrpcPadstackInstance):
         """
         back_drill = super().get_back_drill_by_layer(from_bottom)
         layer = back_drill[0].name
-        offset = round(back_drill[1].value, 9)
-        diameter = round(back_drill[2].value, 9)
+        offset = Value(back_drill[1])
+        diameter = Value(back_drill[2])
         return layer, offset, diameter
 
     def get_back_drill_by_depth(self, from_bottom=True) -> tuple[float, float]:
@@ -730,8 +898,8 @@ class PadstackInstance(GrpcPadstackInstance):
         tuple (drill_depth, drill_diameter) (float, float)
         """
         back_drill = super().get_back_drill_by_depth(from_bottom)
-        drill_depth = back_drill[0].value
-        drill_diameter = back_drill[1].value
+        drill_depth = Value(back_drill[0])
+        drill_diameter = Value(back_drill[1])
         return drill_depth, drill_diameter
 
     def set_back_drill_by_depth(self, drill_depth, diameter, from_bottom=True):
@@ -747,7 +915,7 @@ class PadstackInstance(GrpcPadstackInstance):
             Default value is `True`.
         """
         super().set_back_drill_by_depth(
-            drill_depth=GrpcValue(drill_depth), diameter=GrpcValue(diameter), from_bottom=from_bottom
+            drill_depth=Value(drill_depth), diameter=Value(diameter), from_bottom=from_bottom
         )
 
     def set_back_drill_by_layer(self, drill_to_layer, offset, diameter, from_bottom=True):
@@ -768,8 +936,8 @@ class PadstackInstance(GrpcPadstackInstance):
             drill_to_layer = self._pedb.stackup.layers[drill_to_layer]
         super().set_back_drill_by_layer(
             drill_to_layer=drill_to_layer,
-            offset=GrpcValue(offset),
-            diameter=GrpcValue(diameter),
+            offset=Value(offset),
+            diameter=Value(diameter),
             from_bottom=from_bottom,
         )
 
@@ -812,8 +980,8 @@ class PadstackInstance(GrpcPadstackInstance):
         List[:class:`PadstackInstance <pyedb.grpc.database.primitive.padstack_instance.PadstackInstance>`]
             List of the voids that include this padstack instance.
         """
-        x_pos = GrpcValue(self.position[0])
-        y_pos = GrpcValue(self.position[1])
+        x_pos = Value(self.position[0])
+        y_pos = Value(self.position[1])
         point_data = GrpcPointData([x_pos, y_pos])
 
         voids = []
@@ -1068,7 +1236,7 @@ class PadstackInstance(GrpcPadstackInstance):
                 if point.is_arc:
                     continue
                 else:
-                    points.append([point.x.value, point.y.value])
+                    points.append([Value(point.x), Value(point.y)])
             xpoly, ypoly = zip(*points)
             polygon = [list(xpoly), list(ypoly)]
             rectangles = GeometryOperators.find_largest_rectangle_inside_polygon(
@@ -1086,7 +1254,7 @@ class PadstackInstance(GrpcPadstackInstance):
         for point in path.points:
             if self.component:
                 p_transf = self.component.transform.transform_point(point)
-                new_rect.append([p_transf.x.value, p_transf.y.value])
+                new_rect.append([Value(p_transf.x), Value(p_transf.y)])
         if return_points:
             return new_rect
         else:

pyedb/grpc/database/primitive/path.py

@@ -24,9 +24,9 @@ import math
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
 from ansys.edb.core.primitive.path import Path as GrpcPath
 from ansys.edb.core.primitive.path import PathCornerType as GrpcPatCornerType
-from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.grpc.database.primitive.primitive import Primitive
+from pyedb.grpc.database.utility.value import Value
 
 
 class Path(GrpcPath, Primitive):
@@ -45,11 +45,11 @@ class Path(GrpcPath, Primitive):
         float
             Path width or None.
         """
-        return round(super().width.value, 9)
+        return Value(super().width)
 
     @width.setter
     def width(self, value):
-        super(Path, self.__class__).width.__set__(self, GrpcValue(value))
+        super(Path, self.__class__).width.__set__(self, Value(value))
 
     @property
     def length(self) -> float:
@@ -119,7 +119,7 @@ class Path(GrpcPath, Primitive):
             layout=self._pedb.active_layout,
             layer=self.layer,
             net=self.net,
-            width=GrpcValue(self.width),
+            width=Value(self.width),
             end_cap1=self.get_end_cap_style()[0],
             end_cap2=self.get_end_cap_style()[1],
             corner_style=mapping[self.corner_style],
@@ -289,8 +289,8 @@ class Path(GrpcPath, Primitive):
             rightline.append(rightPt)
             return leftline, rightline
 
-        distance = GrpcValue(distance).value
-        gap = GrpcValue(gap).value
+        distance = Value(distance)
+        gap = Value(gap)
         center_line = self.center_line
         leftline, rightline = get_parallet_lines(center_line, distance)
         for x, y in get_locations(rightline, gap) + get_locations(leftline, gap):
@@ -315,7 +315,7 @@ class Path(GrpcPath, Primitive):
         List[List[float, float]].
 
         """
-        return [[pt.x.value, pt.y.value] for pt in super().center_line.points]
+        return [[Value(pt.x), Value(pt.y)] for pt in super().center_line.points]
 
     # def set_center_line(self, value):
     #     if isinstance(value, list):

pyedb/grpc/database/primitive/polygon.py

@@ -26,9 +26,9 @@ import math
 from ansys.edb.core.geometry.point_data import PointData as GrpcPointData
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
 from ansys.edb.core.primitive.polygon import Polygon as GrpcPolygon
-from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.grpc.database.primitive.primitive import Primitive
+from pyedb.grpc.database.utility.value import Value
 
 
 class Polygon(GrpcPolygon, Primitive):
@@ -147,7 +147,7 @@ class Polygon(GrpcPolygon, Primitive):
         >>>     polygon.move(vector=["2mm", "100um"])
         """
         if vector and isinstance(vector, list) and len(vector) == 2:
-            _vector = [GrpcValue(pt).value for pt in vector]
+            _vector = [Value(pt) for pt in vector]
             self.polygon_data = self.polygon_data.move(_vector)
             return True
         return False
@@ -177,7 +177,7 @@ class Polygon(GrpcPolygon, Primitive):
                 else:
                     self._pedb.logger.error(f"Failed to evaluate center on primitive {self.id}")
             elif isinstance(center, list) and len(center) == 2:
-                center = GrpcPointData([GrpcValue(center[0]), GrpcValue(center[1])])
+                center = GrpcPointData([Value(center[0]), Value(center[1])])
                 self.polygon_data = self.polygon_data.scale(factor, center)
                 return True
         return False

pyedb/grpc/database/primitive/primitive.py

@@ -25,6 +25,7 @@ from ansys.edb.core.geometry.point_data import PointData as GrpcPointData
 from ansys.edb.core.primitive.circle import Circle as GrpcCircle
 from ansys.edb.core.primitive.primitive import Primitive as GrpcPrimitive
 
+from pyedb.grpc.database.utility.value import Value
 from pyedb.misc.utilities import compute_arc_points
 from pyedb.modeler.geometry_operators import GeometryOperators
 
@@ -202,15 +203,15 @@ class Primitive(GrpcPrimitive):
         y = []
         for i, point in enumerate(my_net_points):
             if not point.is_arc:
-                x.append(point.x.value)
-                y.append(point.y.value)
+                x.append(Value(point.x))
+                y.append(Value(point.y))
             else:
-                arc_h = point.arc_height.value
-                p1 = [my_net_points[i - 1].x.value, my_net_points[i - 1].y.value]
+                arc_h = Value(point.arc_height)
+                p1 = [Value(my_net_points[i - 1].x), Value(my_net_points[i - 1].y)]
                 if i + 1 < len(my_net_points):
-                    p2 = [my_net_points[i + 1].x.value, my_net_points[i + 1].y.value]
+                    p2 = [Value(my_net_points[i + 1].x), Value(my_net_points[i + 1].y)]
                 else:
-                    p2 = [my_net_points[0].x.value, my_net_points[0].y.value]
+                    p2 = [Value(my_net_points[0].x), Value(my_net_points[0].y)]
                 x_arc, y_arc = compute_arc_points(p1, p2, arc_h, num)
                 x.extend(x_arc)
                 y.extend(y_arc)
@@ -228,7 +229,7 @@ class Primitive(GrpcPrimitive):
 
         """
         center = self.cast().polygon_data.bounding_circle()[0]
-        return [center.x.value, center.y.value]
+        return [Value(center.x), Value(center.y)]
 
     def get_connected_object_id_set(self) -> list[int]:
         """Produce a list of all geometries physically connected to a given layout object.
@@ -253,12 +254,7 @@ class Primitive(GrpcPrimitive):
 
         """
         bbox = self.cast().polygon_data.bbox()
-        return [
-            round(bbox[0].x.value, 6),
-            round(bbox[0].y.value, 6),
-            round(bbox[1].x.value, 6),
-            round(bbox[1].y.value, 6),
-        ]
+        return [Value(bbox[0].x), Value(bbox[0].y), Value(bbox[1].x), Value(bbox[1].y)]
 
     def convert_to_polygon(self):
         """Convert path to polygon.
@@ -329,7 +325,7 @@ class Primitive(GrpcPrimitive):
             point = GrpcPointData(point)
 
         p0 = self.cast().polygon_data.closest_point(point)
-        return [p0.x.value, p0.y.value]
+        return [Value(p0.x), Value(p0.y)]
 
     @property
     def arcs(self):
@@ -549,16 +545,16 @@ class Primitive(GrpcPrimitive):
         """
 
         if isinstance(point, GrpcPointData):
-            point = [point.x.value, point.y.value]
+            point = [Value(point.x), Value(point.y)]
         dist = 1e12
         out = None
         for arc in self.arcs:
             mid_point = arc.midpoint
-            mid_point = [mid_point.x.value, mid_point.y.value]
+            mid_point = [Value(mid_point.x), Value(mid_point.y)]
             if GeometryOperators.points_distance(mid_point, point) < dist:
                 out = arc.midpoint
                 dist = GeometryOperators.points_distance(mid_point, point)
-        return [out.x.value, out.y.value]
+        return [Value(out.x), Value(out.y)]
 
     @property
     def shortest_arc(self) -> float:

pyedb/grpc/database/primitive/rectangle.py

@@ -25,9 +25,9 @@ from ansys.edb.core.primitive.rectangle import (
     RectangleRepresentationType as GrpcRectangleRepresentationType,
 )
 from ansys.edb.core.primitive.rectangle import Rectangle as GrpcRectangle
-from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.grpc.database.primitive.primitive import Primitive
+from pyedb.grpc.database.utility.value import Value
 
 
 class Rectangle(GrpcRectangle, Primitive):
@@ -106,12 +106,12 @@ class Rectangle(GrpcRectangle, Primitive):
         """
         parameters = super().get_parameters()
         representation_type = parameters[0].name.lower()
-        parameter1 = parameters[1].value
-        parameter2 = parameters[2].value
-        parameter3 = parameters[3].value
-        parameter4 = parameters[4].value
-        corner_radius = parameters[5].value
-        rotation = parameters[6].value
+        parameter1 = Value(parameters[1])
+        parameter2 = Value(parameters[2])
+        parameter3 = Value(parameters[3])
+        parameter4 = Value(parameters[4])
+        corner_radius = Value(parameters[5])
+        rotation = Value(parameters[6])
         return representation_type, parameter1, parameter2, parameter3, parameter4, corner_radius, rotation
 
     def set_parameters(self, rep_type, param1, param2, param3, param4, corner_rad, rotation):
@@ -137,10 +137,10 @@ class Rectangle(GrpcRectangle, Primitive):
 
         return super().set_parameters(
             self.representation_type[rep_type],
-            GrpcValue(param1),
-            GrpcValue(param2),
-            GrpcValue(param3),
-            GrpcValue(param4),
-            GrpcValue(corner_rad),
-            GrpcValue(rotation),
+            Value(param1),
+            Value(param2),
+            Value(param3),
+            Value(param4),
+            Value(corner_rad),
+            Value(rotation),
         )