pyedb 0.49.0__tar.gz → 0.50.1__tar.gz

{pyedb-0.49.0 → pyedb-0.50.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyedb
-Version: 0.49.0
+Version: 0.50.1
 Summary: Higher-Level Pythonic Ansys Electronics Data Base
 Author-email: "ANSYS, Inc." <pyansys.core@ansys.com>
 Maintainer-email: PyEDB developers <simon.vandenbrouck@ansys.com>

{pyedb-0.49.0 → pyedb-0.50.1}/src/pyedb/__init__.py

@@ -44,7 +44,7 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.49.0"
+__version__ = "0.50.1"
 version = __version__
 
 #

{pyedb-0.49.0 → pyedb-0.50.1}/src/pyedb/configuration/cfg_modeler.py

@@ -29,13 +29,15 @@ class CfgTrace:
     def __init__(self, **kwargs):
         self.name = kwargs.get("name", "")
         self.layer = kwargs["layer"]
-        self.path = kwargs["path"]
+        self.path = kwargs.get("path")
         self.width = kwargs["width"]
         self.net_name = kwargs.get("net_name", "")
         self.start_cap_style = kwargs.get("start_cap_style", "round")
         self.end_cap_style = kwargs.get("end_cap_style", "round")
         self.corner_style = kwargs.get("corner_style", "sharp")
 
+        self.incremental_path = kwargs.get("incremental_path")
+
 
 class CfgPlane:
     def __init__(self, **kwargs):
@@ -54,6 +56,10 @@ class CfgPlane:
         # polygon
         self.points = kwargs.get("points", [])
 
+        # circle
+        self.radius = kwargs.get("radius", 0)
+        self.position = kwargs.get("position", [0, 0])
+
 
 class CfgModeler:
     """Manage configuration general settings."""
@@ -153,16 +159,30 @@ class CfgModeler:
         def set_parameter_to_edb(self):
             if self.parent.traces:
                 for t in self.parent.traces:
-                    obj = self._pedb.modeler.create_trace(
-                        path_list=t.path,
-                        layer_name=t.layer,
-                        net_name=t.net_name,
-                        width=t.width,
-                        start_cap_style=t.start_cap_style,
-                        end_cap_style=t.end_cap_style,
-                        corner_style=t.corner_style,
-                    )
-                    obj.aedt_name = t.name
+                    if t.path:
+                        obj = self._pedb.modeler.create_trace(
+                            path_list=t.path,
+                            layer_name=t.layer,
+                            net_name=t.net_name,
+                            width=t.width,
+                            start_cap_style=t.start_cap_style,
+                            end_cap_style=t.end_cap_style,
+                            corner_style=t.corner_style,
+                        )
+                        obj.aedt_name = t.name
+                    else:
+                        obj = self._pedb.modeler.create_trace(
+                            path_list=[t.incremental_path[0]],
+                            layer_name=t.layer,
+                            net_name=t.net_name,
+                            width=t.width,
+                            start_cap_style=t.start_cap_style,
+                            end_cap_style=t.end_cap_style,
+                            corner_style=t.corner_style,
+                        )
+                        obj.aedt_name = t.name
+                        for x, y in t.incremental_path[1:]:
+                            obj.add_point(x, y, True)
 
             if self.parent.padstack_defs:
                 for p in self.parent.padstack_defs:
@@ -202,6 +222,17 @@ class CfgModeler:
                             main_shape=p.points, layer_name=p.layer, net_name=p.net_name
                         )
                         obj.aedt_name = p.name
+                    elif p.type == "circle":
+                        obj = self._pedb.modeler.create_circle(
+                            layer_name=p.layer,
+                            net_name=p.net_name,
+                            x=p.position[0],
+                            y=p.position[1],
+                            radius=p.radius,
+                        )
+                        obj.aedt_name = p.name
+                    else:
+                        raise
 
                     for v in p.voids:
                         for i in self._pedb.layout.primitives:

{pyedb-0.49.0 → pyedb-0.50.1}/src/pyedb/configuration/cfg_ports_sources.py

@@ -391,7 +391,11 @@ class CfgCircuitElement(CfgBase):
         pos_coor_terminal = dict()
         if self.type == "coax":
             pins = self._get_pins(pos_type, pos_value, self.positive_terminal_info.reference_designator)
-            pins = {f"{self.name}_{self.positive_terminal_info.reference_designator}": i for _, i in pins.items()}
+            if len(pins) < 2:
+                pins = {f"{self.name}": i for _, i in pins.items()}
+            else:
+                pins = {f"{self.name}_{name}": i for name, i in pins.items()}
+                self.distributed = True
             pos_objs.update(pins)
         elif pos_type == "coordinates":
             layer = self.positive_terminal_info.layer
@@ -402,10 +406,14 @@ class CfgCircuitElement(CfgBase):
             pos_coor_terminal[self.name] = self._pedb.get_point_terminal(self.name, net_name, point, layer)
 
         elif pos_type == "padstack":
+            flag = False
             for pds in self._pedb.layout.padstack_instances:
                 if pds.aedt_name == pos_value:
                     pos_objs.update({pos_value: pds})
+                    flag = True
                     break
+            if flag is False:
+                raise ValueError(f"Padstack instance {pos_value} does not exist")
         elif pos_type == "pin":
             pins = {
                 pos_value: self._pedb.components.instances[self.positive_terminal_info.reference_designator].pins[

{pyedb-0.49.0 → pyedb-0.50.1}/src/pyedb/dotnet/database/cell/hierarchy/component.py

@@ -308,11 +308,11 @@ class EDBComponent(Group):
         if "GetSolderBallProperty" in dir(self.component_property):
             shape = self.component_property.GetSolderBallProperty().GetShape()
             if shape.value__ == 0:
-                return "None"
+                return "none"
             elif shape.value__ == 1:
-                return "Cylinder"
+                return "cylinder"
             elif shape.value__ == 2:
-                return "Spheroid"
+                return "spheroid"
 
     @solder_ball_shape.setter
     def solder_ball_shape(self, value):
@@ -510,7 +510,7 @@ class EDBComponent(Group):
                 return "0"
             for pinpair in pinpairs:
                 pair = model.GetPinPairRlc(pinpair)
-                return pair.R.ToString()
+                return pair.R.ToDouble()
         return None
 
     @res_value.setter
@@ -539,7 +539,7 @@ class EDBComponent(Group):
                 return "0"
             for pinpair in pinpairs:
                 pair = model.GetPinPairRlc(pinpair)
-                return pair.C.ToString()
+                return pair.C.ToDouble()
         return None
 
     @cap_value.setter
@@ -568,7 +568,7 @@ class EDBComponent(Group):
                 return "0"
             for pinpair in pinpairs:
                 pair = model.GetPinPairRlc(pinpair)
-                return pair.L.ToString()
+                return pair.L.ToDouble()
         return None
 
     @ind_value.setter

{pyedb-0.49.0 → pyedb-0.50.1}/src/pyedb/dotnet/database/components.py

@@ -2362,11 +2362,11 @@ class Components(object):
                 part_name = comp.partname
                 comp_type = comp.type
                 if comp_type == "Resistor":
-                    value = comp.res_value
+                    value = str(comp.res_value)
                 elif comp_type == "Capacitor":
-                    value = comp.cap_value
+                    value = str(comp.cap_value)
                 elif comp_type == "Inductor":
-                    value = comp.ind_value
+                    value = str(comp.ind_value)
                 else:
                     value = ""
                 if not value:

{pyedb-0.49.0 → pyedb-0.50.1}/src/pyedb/dotnet/database/edb_data/padstacks_data.py

@@ -1185,6 +1185,7 @@ class EDBPadstackInstance(Primitive):
         super().__init__(_pedb, edb_padstackinstance)
         self._edb_padstackinstance = self._edb_object
         self._bounding_box = []
+        self._side_number = None
         self._object_instance = None
         self._position = []
         self._pdef = None
@@ -1929,6 +1930,18 @@ class EDBPadstackInstance(Primitive):
         """
         return int(self._edb_padstackinstance.GetGroup().GetPlacementLayer().GetTopBottomAssociation())
 
+    @property
+    def side_number(self) -> float:
+        if not self._side_number:
+            prop_string = "$begin ''\n\tsid=3\n\tmat='copper'\n\tvs='Wirebond'\n$end ''\n"
+            self._edb_padstackinstance.SetProductProperty(self._pedb._edb.ProductId.Designer, 21, prop_string)
+        self._side_number = self._edb_padstackinstance.GetProductProperty(self._pedb._edb.ProductId.Designer, 21)
+        return self._side_number
+
+    @side_number.setter
+    def side_number(self, value):
+        self._side_number = self._edb_padstackinstance.GetProductProperty(self._pedb._edb.ProductId.Designer, 21, value)
+
     def create_rectangle_in_pad(self, layer_name, return_points=False, partition_max_order=16):
         """Create a rectangle inscribed inside a padstack instance pad.
 

{pyedb-0.49.0 → pyedb-0.50.1}/src/pyedb/dotnet/database/edb_data/primitives_data.py

@@ -522,9 +522,9 @@ class EDBArcs(object):
             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]

{pyedb-0.49.0 → pyedb-0.50.1}/src/pyedb/dotnet/database/edb_data/variables.py

@@ -57,7 +57,7 @@ class Variable:
         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 @@ class Variable:
         -------
         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):

{pyedb-0.49.0 → pyedb-0.50.1}/src/pyedb/dotnet/database/materials.py

@@ -88,22 +88,22 @@ def get_line_float_value(line):
 class MaterialProperties(BaseModel):
     """Store material properties."""
 
-    conductivity: Optional[PositiveFloat] = None
-    dielectric_loss_tangent: Optional[PositiveFloat] = None
-    magnetic_loss_tangent: Optional[PositiveFloat] = None
-    mass_density: Optional[PositiveFloat] = None
-    permittivity: Optional[PositiveFloat] = None
-    permeability: Optional[PositiveFloat] = None
-    poisson_ratio: Optional[PositiveFloat] = None
-    specific_heat: Optional[PositiveFloat] = None
-    thermal_conductivity: Optional[PositiveFloat] = None
-    youngs_modulus: Optional[PositiveFloat] = None
-    thermal_expansion_coefficient: Optional[PositiveFloat] = None
-    dc_conductivity: Optional[PositiveFloat] = None
-    dc_permittivity: Optional[PositiveFloat] = None
-    dielectric_model_frequency: Optional[PositiveFloat] = None
-    loss_tangent_at_frequency: Optional[PositiveFloat] = None
-    permittivity_at_frequency: Optional[PositiveFloat] = None
+    conductivity: Optional[PositiveFloat] = 0.0
+    dielectric_loss_tangent: Optional[PositiveFloat] = 0.0
+    magnetic_loss_tangent: Optional[PositiveFloat] = 0.0
+    mass_density: Optional[PositiveFloat] = 0.0
+    permittivity: Optional[PositiveFloat] = 0.0
+    permeability: Optional[PositiveFloat] = 0.0
+    poisson_ratio: Optional[PositiveFloat] = 0.0
+    specific_heat: Optional[PositiveFloat] = 0.0
+    thermal_conductivity: Optional[PositiveFloat] = 0.0
+    youngs_modulus: Optional[PositiveFloat] = 0.0
+    thermal_expansion_coefficient: Optional[PositiveFloat] = 0.0
+    dc_conductivity: Optional[PositiveFloat] = 0.0
+    dc_permittivity: Optional[PositiveFloat] = 0.0
+    dielectric_model_frequency: Optional[PositiveFloat] = 0.0
+    loss_tangent_at_frequency: Optional[PositiveFloat] = 0.0
+    permittivity_at_frequency: Optional[PositiveFloat] = 0.0
 
 
 class Material(object):

{pyedb-0.49.0 → pyedb-0.50.1}/src/pyedb/dotnet/database/modeler.py

@@ -629,7 +629,7 @@ class Modeler(object):
 
         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 @@ class Modeler(object):
             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 @@ class Modeler(object):
         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 @@ class Modeler(object):
                 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
         )

{pyedb-0.49.0 → pyedb-0.50.1}/src/pyedb/dotnet/database/sim_setup_data/data/settings.py

@@ -289,6 +289,34 @@ class AdaptiveSettings(object):
         self.adaptive_settings.AdaptiveFrequencyDataList.Add(high_freq_adapt_data)
         return self._parent._update_setup()
 
+    def add_multi_frequency_adaptive_setup(self, freq_list, max_num_passes=10, max_delta_s=0.02):
+        """Add a setup for frequency data.
+
+        Parameters
+        ----------
+        low_frequency : str, float
+            Frequency with units or float frequency (in Hz).
+        high_frequency : str, float
+            Frequency with units or float frequency (in Hz).
+        max_num_passes : int, optional
+            Maximum number of passes. The default is ``10``.
+        max_delta_s : float, optional
+            Maximum delta S. The default is ``0.02``.
+
+        Returns
+        -------
+        bool
+            ``True`` if method is successful, ``False`` otherwise.
+        """
+        self.adaptive_settings.AdaptiveFrequencyDataList.Clear()
+        for i in freq_list:
+            low_freq_adapt_data = self._parent._pedb.simsetupdata.AdaptiveFrequencyData()
+            low_freq_adapt_data.MaxDelta = self._parent._pedb.edb_value(max_delta_s).ToString()
+            low_freq_adapt_data.MaxPasses = max_num_passes
+            low_freq_adapt_data.AdaptiveFrequency = self._parent._pedb.edb_value(i).ToString()
+            self.adaptive_settings.AdaptiveFrequencyDataList.Add(low_freq_adapt_data)
+        return self._parent._update_setup()
+
 
 class DefeatureSettings(object):
     """Manages EDB methods for defeature settings."""

{pyedb-0.49.0 → pyedb-0.50.1}/src/pyedb/dotnet/database/stackup.py

@@ -885,6 +885,7 @@ class Stackup(LayerCollection):
         else:
             new_layer = self._create_nonstackup_layer(layer_name, layer_type)
             self._set_layout_stackup(new_layer, "non_stackup")
+            return self.non_stackup_layers[layer_name]
         self.refresh_layer_collection()
         return self.layers[layer_name]
 

{pyedb-0.49.0 → pyedb-0.50.1}/src/pyedb/dotnet/database/utilities/hfss_simulation_setup.py

@@ -310,7 +310,7 @@ class HfssSimulationSetup(SimulationSetup):
         self._update_setup()
         return mesh_operation
 
-    def set_solution_single_frequency(self, frequency="5GHz", max_num_passes=10, max_delta_s=0.02):
+    def set_solution_single_frequency(self, frequency="5Ghz", max_num_passes=10, max_delta_s=0.02):
         """Set single-frequency solution.
 
         Parameters
@@ -331,7 +331,7 @@ class HfssSimulationSetup(SimulationSetup):
         self.adaptive_settings.adaptive_settings.AdaptiveFrequencyDataList.Clear()
         return self.adaptive_settings.add_adaptive_frequency_data(frequency, max_num_passes, max_delta_s)
 
-    def set_solution_multi_frequencies(self, frequencies=("5GHz", "10GHz"), max_num_passes=10, max_delta_s="0.02"):
+    def set_solution_multi_frequencies(self, frequencies=("5Ghz", "10Ghz"), max_num_passes=10, max_delta_s="0.02"):
         """Set multi-frequency solution.
 
         Parameters
@@ -350,13 +350,12 @@ class HfssSimulationSetup(SimulationSetup):
         """
         self.adaptive_settings.adapt_type = "kMultiFrequencies"
         self.adaptive_settings.adaptive_settings.AdaptiveFrequencyDataList.Clear()
-        for i in frequencies:
-            if not self.adaptive_settings.add_adaptive_frequency_data(i, max_num_passes, max_delta_s):
-                return False
+        if not self.adaptive_settings.add_multi_frequency_adaptive_setup(frequencies, max_num_passes, max_delta_s):
+            return False
         return True
 
     def set_solution_broadband(
-        self, low_frequency="5GHz", high_frequency="10GHz", max_num_passes=10, max_delta_s="0.02"
+        self, low_frequency="5Ghz", high_frequency="10Ghz", max_num_passes=10, max_delta_s="0.02"
     ):
         """Set broadband solution.
 

{pyedb-0.49.0 → pyedb-0.50.1}/src/pyedb/dotnet/edb.py

@@ -49,7 +49,6 @@ from pyedb.dotnet.database.components import Components
 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 @@ class Edb(Database):
         """
         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
@@ -3022,11 +3021,11 @@ class Edb(Database):
         --------
 
         >>> from pyedb import Edb
-        >>> edb = Edb(edbpath=r"C:\temp\myproject.aedb", edbversion="2023.2")
+        >>> edb = Edb(edbpath="C:\\temp\\myproject.aedb", edbversion="2023.2")
 
         >>> options_config = {'UNITE_NETS' : 1, 'LAUNCH_Q3D' : 0}
-        >>> edb.write_export3d_option_config_file(r"C:\temp", options_config)
-        >>> edb.export_hfss(r"C:\temp")
+        >>> edb.write_export3d_option_config_file(r"C:\\temp", options_config)
+        >>> edb.export_hfss(r"C:\\temp")
         """
         siwave_s = SiwaveSolve(self.edbpath, aedt_installer_path=self.base_path)
         return siwave_s.export_3d_cad("HFSS", path_to_output, net_list, num_cores, aedt_file_name, hidden=hidden)
@@ -3065,10 +3064,10 @@ class Edb(Database):
         --------
 
         >>> from pyedb import Edb
-        >>> edb = Edb(edbpath=r"C:\temp\myproject.aedb", edbversion="2021.2")
+        >>> edb = Edb(edbpath="C:\\temp\\myproject.aedb", edbversion="2021.2")
         >>> options_config = {'UNITE_NETS' : 1, 'LAUNCH_Q3D' : 0}
-        >>> edb.write_export3d_option_config_file(r"C:\temp", options_config)
-        >>> edb.export_q3d(r"C:\temp")
+        >>> edb.write_export3d_option_config_file("C:\\temp", options_config)
+        >>> edb.export_q3d("C:\\temp")
         """
 
         siwave_s = SiwaveSolve(self.edbpath, aedt_installer_path=self.base_path)
@@ -3116,11 +3115,11 @@ class Edb(Database):
 
         >>> from pyedb import Edb
 
-        >>> edb = Edb(edbpath=r"C:\temp\myproject.aedb", edbversion="2021.2")
+        >>> edb = Edb(edbpath="C:\\temp\\myproject.aedb", edbversion="2021.2")
 
         >>> options_config = {'UNITE_NETS' : 1, 'LAUNCH_Q3D' : 0}
-        >>> edb.write_export3d_option_config_file(r"C:\temp", options_config)
-        >>> edb.export_maxwell(r"C:\temp")
+        >>> edb.write_export3d_option_config_file("C:\\temp", options_config)
+        >>> edb.export_maxwell("C:\\temp")
         """
         siwave_s = SiwaveSolve(self.edbpath, aedt_installer_path=self.base_path)
         return siwave_s.export_3d_cad(
@@ -3245,10 +3244,13 @@ class Edb(Database):
         -------
         :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
 
@@ -3758,7 +3760,7 @@ class Edb(Database):
         elif not name:
             name = generate_unique_name("setup")
         setup = HfssSimulationSetup(self, name=name)
-        setup.set_solution_single_frequency("1GΗz")
+        setup.set_solution_single_frequency("1Ghz")
         return setup
 
     def create_raptorx_setup(self, name=None):
@@ -3958,7 +3960,7 @@ class Edb(Database):
             Dictionary with EDB path as key and EDB PolygonData as value defining the zone region.
             This dictionary is returned from the command copy_zones():
             >>> edb = Edb(edb_file)
-            >>> zone_dict = edb.copy_zones(r"C:\Temp\test")
+            >>> zone_dict = edb.copy_zones("C:/Temp/test")
 
         common_reference_net : str
             the common reference net name. This net name must be provided to provide a valid project.
@@ -4017,7 +4019,7 @@ class Edb(Database):
                 dictionary terminals with edb name as key and created ports name on clipped signal nets.
                 Dictionary is generated by the command cutout_multizone_layout:
                 >>> edb = Edb(edb_file)
-                >>> edb_zones = edb.copy_zones(r"C:\Temp\test")
+                >>> edb_zones = edb.copy_zones("C:/Temp/test")
                 >>> defined_ports, terminals_info = edb.cutout_multizone_layout(edb_zones, common_reference_net)
                 >>> project_connexions = get_connected_ports(terminals_info)
 
@@ -4724,6 +4726,6 @@ class Edb(Database):
     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