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

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
 
@@ -386,7 +383,7 @@ class Material(GrpcMaterialDef):
     @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,10 +22,10 @@
 
 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.grpc.database.utility.heat_sink import HeatSink
+from pyedb.grpc.database.utility.value import Value
 from pyedb.misc.misc import deprecated_property
 
 
@@ -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,
             ),
         )

pyedb/grpc/database/definition/padstack_def.py

@@ -35,9 +35,9 @@ from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
 from ansys.edb.core.hierarchy.structure3d import MeshClosure as GrpcMeshClosure
 from ansys.edb.core.hierarchy.structure3d import Structure3D as GrpcStructure3D
 from ansys.edb.core.primitive.circle import Circle as GrpcCircle
-from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.generic.general_methods import generate_unique_name
+from pyedb.grpc.database.utility.value import Value
 
 
 class PadProperties:
@@ -119,7 +119,7 @@ class PadProperties:
             List of parameters.
         """
         try:
-            return [i.value for i in self._pad_parameter_value[1]]
+            return [Value(i) for i in self._pad_parameter_value[1]]
         except TypeError:
             return []
 
@@ -158,7 +158,7 @@ class PadProperties:
         str
             Offset for the X axis.
         """
-        return self._pad_parameter_value[2].value
+        return Value(self._pad_parameter_value[2])
 
     @property
     def offset_y(self) -> float:
@@ -170,7 +170,7 @@ class PadProperties:
             Offset for the Y axis.
         """
 
-        return self._pad_parameter_value[3].value
+        return Value(self._pad_parameter_value[3])
 
     @offset_x.setter
     def offset_x(self, value):
@@ -190,7 +190,7 @@ class PadProperties:
             Value for the rotation.
         """
 
-        return self._pad_parameter_value[4].value
+        return Value(self._pad_parameter_value[4])
 
     @rotation.setter
     def rotation(self, value):
@@ -218,27 +218,27 @@ class PadProperties:
         if params is None:
             params = self._pad_parameter_value[1]
         elif isinstance(params, list):
-            offsetx = [GrpcValue(i, self._pedbpadstack._pedb.db) for i in params]
+            offsetx = [Value(i, self._pedbpadstack._pedb.db) for i in params]
         if rotation is None:
             rotation = self._pad_parameter_value[4]
         elif isinstance(rotation, (str, float, int)):
-            rotation = GrpcValue(rotation, self._pedbpadstack._pedb.db)
+            rotation = Value(rotation, self._pedbpadstack._pedb.db)
         if offsetx is None:
             offsetx = self._pad_parameter_value[2]
         elif isinstance(offsetx, (str, float, int)):
-            offsetx = GrpcValue(offsetx, self._pedbpadstack._pedb.db)
+            offsetx = Value(offsetx, self._pedbpadstack._pedb.db)
         if offsety is None:
             offsety = self._pad_parameter_value[3]
         elif isinstance(offsety, (str, float, int)):
-            offsety = GrpcValue(offsety, self._pedbpadstack._pedb.db)
+            offsety = Value(offsety, self._pedbpadstack._pedb.db)
         self._edb_padstack.set_pad_parameters(
             layer=layer_name,
             pad_type=pad_type,
             type_geom=geom_type,
-            offset_x=GrpcValue(offsetx, self._pedbpadstack._pedb.db),
-            offset_y=GrpcValue(offsety, self._pedbpadstack._pedb.db),
-            rotation=GrpcValue(rotation, self._pedbpadstack._pedb.db),
-            sizes=[GrpcValue(i, self._pedbpadstack._pedb.db) for i in params],
+            offset_x=Value(offsetx, self._pedbpadstack._pedb.db),
+            offset_y=Value(offsety, self._pedbpadstack._pedb.db),
+            rotation=Value(rotation, self._pedbpadstack._pedb.db),
+            sizes=[Value(i, self._pedbpadstack._pedb.db) for i in params],
         )
 
 
@@ -324,7 +324,7 @@ class PadstackDef(GrpcPadstackDef):
         try:
             hole_parameter = self.data.get_hole_parameters()
             if hole_parameter[0].name.lower() == "padgeomtype_circle":
-                return round(hole_parameter[1][0].value, 6)
+                return Value(hole_parameter[1][0])
         except:
             return 0.0
 
@@ -332,9 +332,9 @@ class PadstackDef(GrpcPadstackDef):
     def hole_diameter(self, value):
         hole_parameter = self.data.get_hole_parameters()
         if not isinstance(value, list):
-            value = [GrpcValue(value)]
+            value = [Value(value)]
         else:
-            value = [GrpcValue(p) for p in value]
+            value = [Value(p) for p in value]
         hole_size = value
         geometry_type = hole_parameter[0]
         hole_offset_x = hole_parameter[2]
@@ -359,7 +359,7 @@ class PadstackDef(GrpcPadstackDef):
             hole type.
 
         """
-        return self.data.get_hole_parameters()[0].value
+        return Value(self.data.get_hole_parameters()[0])
 
     @property
     def edb_hole_type(self):
@@ -383,14 +383,14 @@ class PadstackDef(GrpcPadstackDef):
             Hole offset value for the X axis.
         """
         try:
-            return round(self.data.get_hole_parameters()[2].value, 6)
+            return Value(self.data.get_hole_parameters()[2])
         except:
             return 0.0
 
     @hole_offset_x.setter
     def hole_offset_x(self, value):
         hole_parameter = list(self.data.get_hole_parameters())
-        hole_parameter[2] = GrpcValue(value, self._pedb.db)
+        hole_parameter[2] = Value(value, self._pedb.db)
         self.data.set_hole_parameters(
             offset_x=hole_parameter[2],
             offset_y=hole_parameter[3],
@@ -409,14 +409,14 @@ class PadstackDef(GrpcPadstackDef):
             Hole offset value for the Y axis.
         """
         try:
-            return round(self.data.get_hole_parameters()[3].value, 6)
+            return Value(self.data.get_hole_parameters()[3])
         except:
             return 0.0
 
     @hole_offset_y.setter
     def hole_offset_y(self, value):
         hole_parameter = list(self.data.get_hole_parameters())
-        hole_parameter[3] = GrpcValue(value, self._pedb.db)
+        hole_parameter[3] = Value(value, self._pedb.db)
         self.data.set_hole_parameters(
             offset_x=hole_parameter[2],
             offset_y=hole_parameter[3],
@@ -435,14 +435,14 @@ class PadstackDef(GrpcPadstackDef):
             Value for the hole rotation.
         """
         try:
-            return round(self.data.get_hole_parameters()[4].value, 6)
+            return Value(self.data.get_hole_parameters()[4])
         except:
             return 0.0
 
     @hole_rotation.setter
     def hole_rotation(self, value):
         hole_parameter = list(self.data.get_hole_parameters())
-        hole_parameter[4] = GrpcValue(value, self._pedb.db)
+        hole_parameter[4] = Value(value, self._pedb.db)
         self.data.set_hole_parameters(
             offset_x=hole_parameter[2],
             offset_y=hole_parameter[3],
@@ -511,11 +511,11 @@ class PadstackDef(GrpcPadstackDef):
         float
             Percentage for the hole plating.
         """
-        return round(self.data.plating_percentage.value, 6)
+        return Value(self.data.plating_percentage)
 
     @hole_plating_ratio.setter
     def hole_plating_ratio(self, ratio):
-        self.data.plating_percentage = GrpcValue(ratio)
+        self.data.plating_percentage = Value(ratio)
 
     @property
     def hole_plating_thickness(self) -> float:
@@ -543,7 +543,7 @@ class PadstackDef(GrpcPadstackDef):
         float
             Thickness of the hole plating if present.
         """
-        hr = 200 * GrpcValue(value).value / self.hole_diameter
+        hr = 200 * Value(value) / self.hole_diameter
         self.hole_plating_ratio = hr
 
     @property
@@ -671,9 +671,9 @@ class PadstackDef(GrpcPadstackDef):
                         layout,
                         self.start_layer,
                         via.net,
-                        GrpcValue(pos[0]),
-                        GrpcValue(pos[1]),
-                        GrpcValue(self.pad_by_layer[self.start_layer].parameters_values[0] / 2),
+                        Value(pos[0]),
+                        Value(pos[1]),
+                        Value(self.pad_by_layer[self.start_layer].parameters_values[0] / 2),
                     )
                 if len(self.pad_by_layer[self.stop_layer].parameters_values) == 0:
                     self._pedb.modeler.create_polygon(
@@ -686,9 +686,9 @@ class PadstackDef(GrpcPadstackDef):
                         layout,
                         self.stop_layer,
                         via.net,
-                        GrpcValue(pos[0]),
-                        GrpcValue(pos[1]),
-                        GrpcValue(self.pad_by_layer[self.stop_layer].parameters_values[0] / 2),
+                        Value(pos[0]),
+                        Value(pos[1]),
+                        Value(self.pad_by_layer[self.stop_layer].parameters_values[0] / 2),
                     )
                 for layer_name in layer_names:
                     stop = ""
@@ -699,17 +699,17 @@ class PadstackDef(GrpcPadstackDef):
                             layout,
                             start,
                             via.net,
-                            GrpcValue(pos[0]),
-                            GrpcValue(pos[1]),
-                            GrpcValue(rad1),
+                            Value(pos[0]),
+                            Value(pos[1]),
+                            Value(rad1),
                         )
                         cloned_circle2 = GrpcCircle.create(
                             layout,
                             stop,
                             via.net,
-                            GrpcValue(pos[0]),
-                            GrpcValue(pos[1]),
-                            GrpcValue(rad2),
+                            Value(pos[0]),
+                            Value(pos[1]),
+                            Value(rad2),
                         )
                         s3d = GrpcStructure3D.create(
                             layout, generate_unique_name("via3d_" + via.aedt_name.replace("via_", ""), n=3)
@@ -771,9 +771,9 @@ class PadstackDef(GrpcPadstackDef):
                     new_padstack_definition.data.set_pad_parameters(
                         layer=layer,
                         pad_type=GrpcPadType.REGULAR_PAD,
-                        offset_x=GrpcValue(pl.offset_x, self._pedb.db),
-                        offset_y=GrpcValue(pl.offset_y, self._pedb.db),
-                        rotation=GrpcValue(pl.rotation, self._pedb.db),
+                        offset_x=Value(pl.offset_x, self._pedb.db),
+                        offset_y=Value(pl.offset_y, self._pedb.db),
+                        rotation=Value(pl.rotation, self._pedb.db),
                         type_geom=pl._edb_geometry_type,
                         sizes=pl.parameters_values,
                     )
@@ -783,9 +783,9 @@ class PadstackDef(GrpcPadstackDef):
                         new_padstack_definition.data.set_pad_parameters(
                             layer=layer,
                             pad_type=GrpcPadType.ANTI_PAD,
-                            offset_x=GrpcValue(pl.offset_x, self._pedb.db),
-                            offset_y=GrpcValue(pl.offset_y, self._pedb.db),
-                            rotation=GrpcValue(pl.rotation, self._pedb.db),
+                            offset_x=Value(pl.offset_x, self._pedb.db),
+                            offset_y=Value(pl.offset_y, self._pedb.db),
+                            rotation=Value(pl.rotation, self._pedb.db),
                             type_geom=pl._edb_geometry_type,
                             sizes=pl.parameters_values,
                         )
@@ -795,21 +795,21 @@ class PadstackDef(GrpcPadstackDef):
                         new_padstack_definition.data.set_pad_parameters(
                             layer=layer,
                             pad_type=GrpcPadType.THERMAL_PAD,
-                            offset_x=GrpcValue(pl.offset_x, self._pedb.db),
-                            offset_y=GrpcValue(pl.offset_y, self._pedb.db),
-                            rotation=GrpcValue(pl.rotation, self._pedb.db),
+                            offset_x=Value(pl.offset_x, self._pedb.db),
+                            offset_y=Value(pl.offset_y, self._pedb.db),
+                            rotation=Value(pl.rotation, self._pedb.db),
                             type_geom=pl._edb_geometry_type,
                             sizes=pl.parameters_values,
                         )
                 new_padstack_definition.data.set_hole_parameters(
-                    offset_x=GrpcValue(self.hole_offset_x, self._pedb.db),
-                    offset_y=GrpcValue(self.hole_offset_y, self._pedb.db),
-                    rotation=GrpcValue(self.hole_rotation, self._pedb.db),
+                    offset_x=Value(self.hole_offset_x, self._pedb.db),
+                    offset_y=Value(self.hole_offset_y, self._pedb.db),
+                    rotation=Value(self.hole_rotation, self._pedb.db),
                     type_geom=self.edb_hole_type,
                     sizes=[self.hole_diameter],
                 )
                 new_padstack_definition.data.material = self.material
-                new_padstack_definition.data.plating_percentage = GrpcValue(self.hole_plating_ratio, self._pedb.db)
+                new_padstack_definition.data.plating_percentage = Value(self.hole_plating_ratio, self._pedb.db)
                 new_instances.append(PadstackDef(self._pedb, new_padstack_definition))
                 started = True
             if self.stop_layer == stop:

pyedb/grpc/database/geometry/arc_data.py

@@ -23,6 +23,8 @@
 
 from ansys.edb.core.geometry.arc_data import ArcData as GrpcArcData
 
+from pyedb.grpc.database.utility.value import Value
+
 
 class ArcData(GrpcArcData):
     """Class managing ArcData."""
@@ -42,7 +44,7 @@ class ArcData(GrpcArcData):
             [x value, y value]
 
         """
-        return [self.center.x.value, self.center.y.value]
+        return [Value(super().center.x), Value(super().center.y)]
 
     @property
     def start(self) -> list[float]:
@@ -54,7 +56,7 @@ class ArcData(GrpcArcData):
             [x value, y value]
 
         """
-        return [self.start.x.value, self.start.y.value]
+        return [Value(super().start.x), Value(super().start.y)]
 
     @property
     def end(self) -> list[float]:
@@ -66,7 +68,7 @@ class ArcData(GrpcArcData):
             [x value, y value]
 
         """
-        return [self.end.x.value, self.end.y.value]
+        return [Value(self.end.x), Value(self.end.y)]
 
     @property
     def mid_point(self) -> list[float]:
@@ -78,7 +80,7 @@ class ArcData(GrpcArcData):
             [x value, y value]
 
         """
-        return [self.midpoint.x.value, self.midpoint.y.value]
+        return [Value(self.midpoint.x), Value(self.midpoint.y)]
 
     @property
     def points(self) -> list[list[float]]:
@@ -90,4 +92,4 @@ class ArcData(GrpcArcData):
             [[x value, y value]]
 
         """
-        return [[pt.x.value, pt.y.value] for pt in self.points]
+        return [[Value(pt.x), Value(pt.y)] for pt in self.points]