FEAT: modeler grpc compatibility

src/pyedb/dotnet/database/edb_data/primitives_data.py

@@ -522,9 +522,9 @@ def points(self, arc_segments=6):
             xt, yt = self._app._active_cell.primitive._get_points_for_plot(my_net_points, arc_segments)
             if not xt:
                 return []
-            x, y = GeometryOperators.orient_polygon(xt, yt, clockwise=True)
-            return x, y
+            x, y = list(GeometryOperators.orient_polygon(xt, yt, clockwise=True))
+            return [x, y]
         except:
             x = []
             y = []
-        return x, y
+        return [x, y]

src/pyedb/dotnet/database/edb_data/variables.py

@@ -57,7 +57,7 @@ def value_string(self):
         str
 
         """
-        return self._pedb.get_variable(self.name).tostring
+        return self._var_server.GetVariableValue(self.name)[1].ToString()
 
     @property
     def value_object(self):
@@ -77,11 +77,11 @@ def value(self):
         -------
         float
         """
-        return self._pedb.get_variable(self.name).tofloat
+        return self._var_server.GetVariableValue(self.name)[1].ToDouble()
 
     @value.setter
     def value(self, value):
-        self._pedb.change_design_variable_value(self.name, value)
+        self._var_server.SetVariableValue(self.name, self._pedb.edb_value(value))
 
     @property
     def description(self):

src/pyedb/dotnet/database/modeler.py

@@ -629,7 +629,7 @@ def create_trace(
 
         return primitive
 
-    def create_polygon(self, main_shape, layer_name, voids=[], net_name=""):
+    def create_polygon(self, main_shape=None, layer_name="", voids=[], net_name="", points=None):
         """Create a polygon based on a list of points and voids.
 
         Parameters
@@ -646,13 +646,40 @@ def create_polygon(self, main_shape, layer_name, voids=[], net_name=""):
             List of shape objects for voids or points that creates the shapes. The default is``[]``.
         net_name : str, optional
             Name of the net. The default is ``""``.
+        points : list, optional
+            Added for compatibility with grpc.
 
         Returns
         -------
         bool, :class:`dotnet.database.edb_data.primitives.Primitive`
             Polygon when successful, ``False`` when failed.
         """
+        from pyedb.dotnet.database.geometry.polygon_data import PolygonData
+
+        if main_shape:
+            warnings.warn(
+                "main_shape argument will be deprecated soon with grpc version, use points instead.", DeprecationWarning
+            )
+
         net = self._pedb.nets.find_or_create_net(net_name)
+        if points:
+            arcs = []
+            if isinstance(points, PolygonData):
+                points = points.points
+            for _ in range(len(points)):
+                arcs.append(
+                    self._edb.Geometry.ArcData(
+                        self._pedb.point_data(0, 0),
+                        self._pedb.point_data(0, 0),
+                    )
+                )
+            polygonData = self._edb.Geometry.PolygonData.CreateFromArcs(convert_py_list_to_net_list(arcs), True)
+
+            for idx, i in enumerate(points):
+                pdata_0 = self._pedb.edb_value(i[0])
+                pdata_1 = self._pedb.edb_value(i[1])
+                new_points = self._edb.Geometry.PointData(pdata_0, pdata_1)
+                polygonData.SetPoint(idx, new_points)
         if isinstance(main_shape, list):
             arcs = []
             for _ in range(len(main_shape)):
@@ -673,9 +700,14 @@ def create_polygon(self, main_shape, layer_name, voids=[], net_name=""):
         elif isinstance(main_shape, Modeler.Shape):
             polygonData = self.shape_to_polygon_data(main_shape)
         else:
-            polygonData = main_shape
-        if not polygonData or polygonData.IsNull():
-            raise RuntimeError("Failed to create main shape polygon data")
+            if not points:
+                polygonData = main_shape
+        if isinstance(polygonData, PolygonData):
+            if not polygonData.points:
+                raise RuntimeError("Failed to create main shape polygon data")
+        else:
+            if polygonData.IsNull():
+                raise RuntimeError("Failed to create main shape polygon data")
         for void in voids:
             if isinstance(void, list):
                 void = self.Shape("polygon", points=void)
@@ -689,6 +721,8 @@ def create_polygon(self, main_shape, layer_name, voids=[], net_name=""):
                 self._logger.error("Failed to create void polygon data")
                 return False
             polygonData.AddHole(voidPolygonData)
+        if isinstance(polygonData, PolygonData):
+            polygonData = polygonData._edb_object
         polygon = self._pedb._edb.Cell.Primitive.Polygon.Create(
             self._active_layout, layer_name, net.net_obj, polygonData
         )

src/pyedb/dotnet/edb.py

@@ -49,7 +49,6 @@
 import pyedb.dotnet.database.dotnet.database
 from pyedb.dotnet.database.dotnet.database import Database
 from pyedb.dotnet.database.edb_data.design_options import EdbDesignOptions
-from pyedb.dotnet.database.edb_data.edbvalue import EdbValue
 from pyedb.dotnet.database.edb_data.ports import (
     BundleWavePort,
     CircuitPort,
@@ -461,9 +460,9 @@ def variables(self):
         """
         all_vars = dict()
         for i, j in self.project_variables.items():
-            all_vars[i] = j
+            all_vars[i] = j.value
         for i, j in self.design_variables.items():
-            all_vars[i] = j
+            all_vars[i] = j.value
         return all_vars
 
     @property
@@ -3245,10 +3244,13 @@ def get_variable(self, variable_name):
         -------
         :class:`pyedb.dotnet.database.edb_data.edbvalue.EdbValue`
         """
-        var_server = self.variable_exists(variable_name)
-        if var_server[0]:
-            tuple_value = var_server[1].GetVariableValue(variable_name)
-            return EdbValue(tuple_value[1])
+
+        for i, j in self.project_variables.items():
+            if i == variable_name:
+                return j
+        for i, j in self.design_variables.items():
+            if i == variable_name:
+                return j
         self.logger.info("Variable %s doesn't exists.", variable_name)
         return None
 
@@ -4724,6 +4726,6 @@ def export_gds_comp_xml(self, comps_to_export, gds_comps_unit="mm", control_path
     def get_variable_value(self, variable_name):
         """Added to get closer architecture as for grpc."""
         if variable_name in self.variables:
-            return self.variables[variable_name].value
+            return self.variables[variable_name]
         else:
             return False

src/pyedb/grpc/database/primitive/path.py

@@ -62,7 +62,7 @@ def length(self):
         """
         center_line_arcs = self._edb_object.cast().center_line.arc_data
         path_length = 0.0
-        for arc in center_line_arcs[: int(len(center_line_arcs) / 2)]:
+        for arc in center_line_arcs:
             path_length += arc.length
         end_cap_style = self.get_end_cap_style()
         if end_cap_style:

src/pyedb/grpc/edb.py

@@ -2821,39 +2821,43 @@ def get_variable(self, variable_name):
         self.logger.info(f"Variable {variable_name} doesn't exists.")
         return False
 
-    def add_project_variable(self, variable_name, variable_value):
+    def add_project_variable(self, variable_name, variable_value, description=None):
         """Add a variable to database. The variable will have the prefix `$`.
 
         Parameters
-         ----------
-         variable_name : str
-             Name of the variable. Name can be provided without ``$`` prefix.
-         variable_value : str, float
-             Value of the variable with units.
+        ----------
+        variable_name : str
+            Name of the variable. Name can be provided without ``$`` prefix.
+        variable_value : str, float
+            Value of the variable with units.
+        description : str, optional.
+            Add variable description.
 
-         Returns
-         -------
-         bool
+        Returns
+        -------
+        bool
 
-         Examples
-         --------
+        Examples
+        --------
 
-         >>> from pyedb import Edb
-         >>> edb_app = Edb()
-         >>> boolean_1, ant_length = edb_app.add_project_variable("my_local_variable", "1cm")
-         >>> print(edb_app["$my_local_variable"])    #using getitem
-         >>> edb_app["$my_local_variable"] = "1cm"   #using setitem
+        >>> from pyedb import Edb
+        >>> edb_app = Edb()
+        >>> boolean_1, ant_length = edb_app.add_project_variable("my_local_variable", "1cm")
+        >>> print(edb_app["$my_local_variable"])    #using getitem
+        >>> edb_app["$my_local_variable"] = "1cm"   #using setitem
 
         """
         if not variable_name.startswith("$"):
             variable_name = f"${variable_name}"
         if not self.variable_exists(variable_name):
-            return self.active_db.add_variable(variable_name, variable_value)
+            var = self.active_db.add_variable(variable_name, variable_value)
+            if description:
+                self.active_db.set_variable_desc(name=variable_name, desc=description)
         else:
             self.logger.error(f"Variable {variable_name} already exists.")
             return False
 
-    def add_design_variable(self, variable_name, variable_value, is_parameter=False):
+    def add_design_variable(self, variable_name, variable_value, is_parameter=False, description=None):
         """Add a variable to edb. The variable can be a design one or a project variable (using ``$`` prefix).
 
         Parameters
@@ -2866,6 +2870,8 @@ def add_design_variable(self, variable_name, variable_value, is_parameter=False)
         is_parameter : bool, optional
             Whether to add the variable as a local variable. The default is ``False``.
             When ``True``, the variable is added as a parameter default.
+        description : str, optional
+            Add variable description.
 
         Returns
         -------
@@ -2887,7 +2893,10 @@ def add_design_variable(self, variable_name, variable_value, is_parameter=False)
         if variable_name.startswith("$"):
             variable_name = variable_name[1:]
         if not self.variable_exists(variable_name):
-            return self.active_cell.add_variable(variable_name, variable_value)
+            var = self.active_cell.add_variable(variable_name, variable_value)
+            if description:
+                self.active_cell.set_variable_desc(name=variable_name, desc=description)
+            return var
         else:
             self.logger.error(f"Variable {variable_name} already exists.")
             return False